blob: ff55734897d34eb64e1b71f10107d8ed2a20f648 [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 Tarreaub00a8e32021-05-08 20:18:59 +020036#include <haproxy/proxy.h>
Willy Tarreaua55c4542020-06-04 22:59:39 +020037#include <haproxy/queue.h>
Emeric Brunc9437992021-02-12 19:42:55 +010038#include <haproxy/resolvers.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020039#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020040#include <haproxy/server.h>
William Dauchyf6370442020-11-14 19:25:33 +010041#include <haproxy/ssl_sock.h>
Amaury Denoyellef99f77a2021-03-08 17:13:32 +010042#include <haproxy/stats.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020043#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020044#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020045#include <haproxy/task.h>
Willy Tarreau51cd5952020-06-05 12:25:38 +020046#include <haproxy/tcpcheck.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020047#include <haproxy/time.h>
Willy Tarreauba6300e2021-05-08 14:09:40 +020048#include <haproxy/tools.h>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020049
Baptiste Assmannda29fe22019-06-13 13:24:29 +020050
Willy Tarreau3ff577e2018-08-02 11:48:52 +020051static void srv_update_status(struct server *s);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010052static int srv_apply_lastaddr(struct server *srv, int *err_code);
William Dauchy6318d332020-05-02 21:52:36 +020053static void srv_cleanup_connections(struct server *srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +020054
Amaury Denoyelle587b71e2021-03-10 16:36:02 +010055/* extra keywords used as value for other arguments. They are used as
56 * suggestions for mistyped words.
Willy Tarreau49c2b452021-03-12 09:58:04 +010057 */
Amaury Denoyelle587b71e2021-03-10 16:36:02 +010058static const char *extra_kw_list[] = {
59 "ipv4", "ipv6", "legacy", "octet-count",
Amaury Denoyelle3b89c112021-03-12 16:04:00 +010060 "fail-check", "sudden-death", "mark-down",
Willy Tarreau49c2b452021-03-12 09:58:04 +010061 NULL /* must be last */
62};
63
Willy Tarreau21faa912012-10-10 08:27:36 +020064/* List head of all known server keywords */
65static struct srv_kw_list srv_keywords = {
66 .list = LIST_HEAD_INIT(srv_keywords.list)
67};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020068
Willy Tarreauaf613e82020-06-05 08:40:51 +020069__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010070struct eb_root idle_conn_srv = EB_ROOT;
Willy Tarreau14015b82021-04-10 17:33:15 +020071struct task *idle_conn_task __read_mostly = NULL;
Willy Tarreau198e92a2021-03-05 10:23:32 +010072struct list servers_list = LIST_HEAD_INIT(servers_list);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010073
Frédéric Lécaille7da71292019-05-20 09:47:07 +020074/* The server names dictionary */
Thayne McCombs92149f92020-11-20 01:28:26 -070075struct dict server_key_dict = {
76 .name = "server keys",
Frédéric Lécaille7da71292019-05-20 09:47:07 +020077 .values = EB_ROOT_UNIQUE,
78};
79
Simon Hormana3608442013-11-01 16:46:15 +090080int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020081{
Amaury Denoyellee6ba7912020-10-29 15:59:05 +010082 if ((s->cur_state != SRV_ST_STOPPED) || s->last_change >= now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020083 return s->down_time;
84
85 return now.tv_sec - s->last_change + s->down_time;
86}
Willy Tarreaubaaee002006-06-26 02:48:02 +020087
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050088int srv_lastsession(const struct server *s)
89{
90 if (s->counters.last_sess)
91 return now.tv_sec - s->counters.last_sess;
92
93 return -1;
94}
95
Simon Horman4a741432013-02-23 15:35:38 +090096int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020097{
Simon Horman4a741432013-02-23 15:35:38 +090098 const struct server *s = check->server;
99
Willy Tarreauff5ae352013-12-11 20:36:34 +0100100 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +0900101 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100102
Emeric Brun52a91d32017-08-31 14:41:55 +0200103 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +0900104 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100105
Simon Horman4a741432013-02-23 15:35:38 +0900106 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100107}
108
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100109/*
110 * Check that we did not get a hash collision.
Willy Tarreau595e7672020-10-20 17:30:08 +0200111 * Unlikely, but it can happen. The server's proxy must be at least
112 * read-locked.
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100113 */
114static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +0100115{
116 struct proxy *p = s->proxy;
117 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100118
119 for (tmpserv = p->srv; tmpserv != NULL;
120 tmpserv = tmpserv->next) {
121 if (tmpserv == s)
122 continue;
123 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
124 continue;
125 if (tmpserv->cookie &&
126 strcmp(tmpserv->cookie, s->cookie) == 0) {
127 ha_warning("We generated two equal cookies for two different servers.\n"
128 "Please change the secret key for '%s'.\n",
129 s->proxy->id);
130 }
131 }
132
133}
134
Willy Tarreau46b7f532018-08-21 11:54:26 +0200135/*
Willy Tarreau595e7672020-10-20 17:30:08 +0200136 * Must be called with the server lock held, and will read-lock the proxy.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200137 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100138void srv_set_dyncookie(struct server *s)
139{
140 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100141 char *tmpbuf;
142 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100143 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100144 size_t buffer_len;
145 int addr_len;
146 int port;
147
Willy Tarreau595e7672020-10-20 17:30:08 +0200148 HA_RWLOCK_RDLOCK(PROXY_LOCK, &p->lock);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200149
Olivier Houchard4e694042017-03-14 20:01:29 +0100150 if ((s->flags & SRV_F_COOKIESET) ||
151 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
152 s->proxy->dyncookie_key == NULL)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200153 goto out;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100154 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100155
156 if (s->addr.ss_family != AF_INET &&
157 s->addr.ss_family != AF_INET6)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200158 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100159 /*
160 * Buffer to calculate the cookie value.
161 * The buffer contains the secret key + the server IP address
162 * + the TCP port.
163 */
164 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
165 /*
166 * The TCP port should use only 2 bytes, but is stored in
167 * an unsigned int in struct server, so let's use 4, to be
168 * on the safe side.
169 */
170 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200171 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100172 memcpy(tmpbuf, p->dyncookie_key, key_len);
173 memcpy(&(tmpbuf[key_len]),
174 s->addr.ss_family == AF_INET ?
175 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
176 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
177 addr_len);
178 /*
179 * Make sure it's the same across all the load balancers,
180 * no matter their endianness.
181 */
182 port = htonl(s->svc_port);
183 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
184 hash_value = XXH64(tmpbuf, buffer_len, 0);
185 memprintf(&s->cookie, "%016llx", hash_value);
186 if (!s->cookie)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200187 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100188 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100189
190 /* Don't bother checking if the dyncookie is duplicated if
191 * the server is marked as "disabled", maybe it doesn't have
192 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100193 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100194 if (!(s->next_admin & SRV_ADMF_FMAINT))
195 srv_check_for_dup_dyncookie(s);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200196 out:
Willy Tarreau595e7672020-10-20 17:30:08 +0200197 HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &p->lock);
Olivier Houchard4e694042017-03-14 20:01:29 +0100198}
199
Willy Tarreau21faa912012-10-10 08:27:36 +0200200/*
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +0200201 * Must be called with the server lock held. The server is first removed from
202 * the proxy tree if it was already attached. If <reattach> is true, the server
203 * will then be attached in the proxy tree. The proxy lock is held to
204 * manipulate the tree.
Thayne McCombs92149f92020-11-20 01:28:26 -0700205 */
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +0200206static void srv_set_addr_desc(struct server *s, int reattach)
Thayne McCombs92149f92020-11-20 01:28:26 -0700207{
208 struct proxy *p = s->proxy;
209 char *key;
210
211 key = sa2str(&s->addr, s->svc_port, s->flags & SRV_F_MAPPORTS);
212
213 if (s->addr_node.key) {
Thayne McCombs24da7e12021-01-05 23:10:09 -0700214 if (key && strcmp(key, s->addr_node.key) == 0) {
Thayne McCombs92149f92020-11-20 01:28:26 -0700215 free(key);
216 return;
217 }
218
219 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
220 ebpt_delete(&s->addr_node);
221 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
222
223 free(s->addr_node.key);
224 }
225
226 s->addr_node.key = key;
227
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +0200228 if (reattach) {
229 if (s->addr_node.key) {
230 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
231 ebis_insert(&p->used_server_addr, &s->addr_node);
232 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
233 }
Thayne McCombs24da7e12021-01-05 23:10:09 -0700234 }
Thayne McCombs92149f92020-11-20 01:28:26 -0700235}
236
237/*
Willy Tarreau21faa912012-10-10 08:27:36 +0200238 * Registers the server keyword list <kwl> as a list of valid keywords for next
239 * parsing sessions.
240 */
241void srv_register_keywords(struct srv_kw_list *kwl)
242{
Willy Tarreau2b718102021-04-21 07:32:39 +0200243 LIST_APPEND(&srv_keywords.list, &kwl->list);
Willy Tarreau21faa912012-10-10 08:27:36 +0200244}
245
246/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
247 * keyword is found with a NULL ->parse() function, then an attempt is made to
248 * find one with a valid ->parse() function. This way it is possible to declare
249 * platform-dependant, known keywords as NULL, then only declare them as valid
250 * if some options are met. Note that if the requested keyword contains an
251 * opening parenthesis, everything from this point is ignored.
252 */
253struct srv_kw *srv_find_kw(const char *kw)
254{
255 int index;
256 const char *kwend;
257 struct srv_kw_list *kwl;
258 struct srv_kw *ret = NULL;
259
260 kwend = strchr(kw, '(');
261 if (!kwend)
262 kwend = kw + strlen(kw);
263
264 list_for_each_entry(kwl, &srv_keywords.list, list) {
265 for (index = 0; kwl->kw[index].kw != NULL; index++) {
266 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
267 kwl->kw[index].kw[kwend-kw] == 0) {
268 if (kwl->kw[index].parse)
269 return &kwl->kw[index]; /* found it !*/
270 else
271 ret = &kwl->kw[index]; /* may be OK */
272 }
273 }
274 }
275 return ret;
276}
277
278/* Dumps all registered "server" keywords to the <out> string pointer. The
279 * unsupported keywords are only dumped if their supported form was not
280 * found.
281 */
282void srv_dump_kws(char **out)
283{
284 struct srv_kw_list *kwl;
285 int index;
286
Christopher Faulet784063e2020-05-18 12:14:18 +0200287 if (!out)
288 return;
289
Willy Tarreau21faa912012-10-10 08:27:36 +0200290 *out = NULL;
291 list_for_each_entry(kwl, &srv_keywords.list, list) {
292 for (index = 0; kwl->kw[index].kw != NULL; index++) {
293 if (kwl->kw[index].parse ||
294 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
295 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
296 kwl->scope,
297 kwl->kw[index].kw,
298 kwl->kw[index].skip ? " <arg>" : "",
299 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
300 kwl->kw[index].parse ? "" : " (not supported)");
301 }
302 }
303 }
Willy Tarreau49c2b452021-03-12 09:58:04 +0100304}
305
306/* Try to find in srv_keyword the word that looks closest to <word> by counting
307 * transitions between letters, digits and other characters. Will return the
308 * best matching word if found, otherwise NULL. An optional array of extra
309 * words to compare may be passed in <extra>, but it must then be terminated
310 * by a NULL entry. If unused it may be NULL.
311 */
312static const char *srv_find_best_kw(const char *word)
313{
314 uint8_t word_sig[1024];
315 uint8_t list_sig[1024];
316 const struct srv_kw_list *kwl;
317 const char *best_ptr = NULL;
318 int dist, best_dist = INT_MAX;
319 const char **extra;
320 int index;
321
322 make_word_fingerprint(word_sig, word);
323 list_for_each_entry(kwl, &srv_keywords.list, list) {
324 for (index = 0; kwl->kw[index].kw != NULL; index++) {
325 make_word_fingerprint(list_sig, kwl->kw[index].kw);
326 dist = word_fingerprint_distance(word_sig, list_sig);
327 if (dist < best_dist) {
328 best_dist = dist;
329 best_ptr = kwl->kw[index].kw;
330 }
331 }
332 }
333
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100334 for (extra = extra_kw_list; *extra; extra++) {
Willy Tarreau49c2b452021-03-12 09:58:04 +0100335 make_word_fingerprint(list_sig, *extra);
336 dist = word_fingerprint_distance(word_sig, list_sig);
337 if (dist < best_dist) {
338 best_dist = dist;
339 best_ptr = *extra;
340 }
Willy Tarreau49c2b452021-03-12 09:58:04 +0100341 }
342
343 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
344 best_ptr = NULL;
345
346 return best_ptr;
Willy Tarreau21faa912012-10-10 08:27:36 +0200347}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100348
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100349/* Parse the "backup" server keyword */
350static int srv_parse_backup(char **args, int *cur_arg,
351 struct proxy *curproxy, struct server *newsrv, char **err)
352{
353 newsrv->flags |= SRV_F_BACKUP;
354 return 0;
355}
356
Alexander Liu2a54bb72019-05-22 19:44:48 +0800357
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100358/* Parse the "cookie" server keyword */
359static int srv_parse_cookie(char **args, int *cur_arg,
360 struct proxy *curproxy, struct server *newsrv, char **err)
361{
362 char *arg;
363
364 arg = args[*cur_arg + 1];
365 if (!*arg) {
366 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
367 return ERR_ALERT | ERR_FATAL;
368 }
369
370 free(newsrv->cookie);
371 newsrv->cookie = strdup(arg);
372 newsrv->cklen = strlen(arg);
373 newsrv->flags |= SRV_F_COOKIESET;
374 return 0;
375}
376
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100377/* Parse the "disabled" server keyword */
378static int srv_parse_disabled(char **args, int *cur_arg,
379 struct proxy *curproxy, struct server *newsrv, char **err)
380{
Emeric Brun52a91d32017-08-31 14:41:55 +0200381 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
382 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100383 newsrv->check.state |= CHK_ST_PAUSED;
384 newsrv->check.health = 0;
385 return 0;
386}
387
388/* Parse the "enabled" server keyword */
389static int srv_parse_enabled(char **args, int *cur_arg,
390 struct proxy *curproxy, struct server *newsrv, char **err)
391{
Emeric Brun52a91d32017-08-31 14:41:55 +0200392 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
393 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100394 newsrv->check.state &= ~CHK_ST_PAUSED;
395 newsrv->check.health = newsrv->check.rise;
396 return 0;
397}
398
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100399/* Parse the "error-limit" server keyword */
400static int srv_parse_error_limit(char **args, int *cur_arg,
401 struct proxy *curproxy, struct server *newsrv, char **err)
402{
403 if (!*args[*cur_arg + 1]) {
404 memprintf(err, "'%s' expects an integer argument.",
405 args[*cur_arg]);
406 return ERR_ALERT | ERR_FATAL;
407 }
408
409 newsrv->consecutive_errors_limit = atoi(args[*cur_arg + 1]);
410
411 if (newsrv->consecutive_errors_limit <= 0) {
412 memprintf(err, "%s has to be > 0.",
413 args[*cur_arg]);
414 return ERR_ALERT | ERR_FATAL;
415 }
416
417 return 0;
418}
419
420/* Parse the "init-addr" server keyword */
421static int srv_parse_init_addr(char **args, int *cur_arg,
422 struct proxy *curproxy, struct server *newsrv, char **err)
423{
424 char *p, *end;
425 int done;
426 struct sockaddr_storage sa;
427
428 newsrv->init_addr_methods = 0;
429 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
430
431 for (p = args[*cur_arg + 1]; *p; p = end) {
432 /* cut on next comma */
433 for (end = p; *end && *end != ','; end++);
434 if (*end)
435 *(end++) = 0;
436
437 memset(&sa, 0, sizeof(sa));
438 if (strcmp(p, "libc") == 0) {
439 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
440 }
441 else if (strcmp(p, "last") == 0) {
442 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
443 }
444 else if (strcmp(p, "none") == 0) {
445 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
446 }
447 else if (str2ip2(p, &sa, 0)) {
448 if (is_addr(&newsrv->init_addr)) {
449 memprintf(err, "'%s' : initial address already specified, cannot add '%s'.",
450 args[*cur_arg], p);
451 return ERR_ALERT | ERR_FATAL;
452 }
453 newsrv->init_addr = sa;
454 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
455 }
456 else {
457 memprintf(err, "'%s' : unknown init-addr method '%s', supported methods are 'libc', 'last', 'none'.",
458 args[*cur_arg], p);
459 return ERR_ALERT | ERR_FATAL;
460 }
461 if (!done) {
462 memprintf(err, "'%s' : too many init-addr methods when trying to add '%s'",
463 args[*cur_arg], p);
464 return ERR_ALERT | ERR_FATAL;
465 }
466 }
467
468 return 0;
469}
470
471/* Parse the "log-proto" server keyword */
472static int srv_parse_log_proto(char **args, int *cur_arg,
473 struct proxy *curproxy, struct server *newsrv, char **err)
474{
475 if (strcmp(args[*cur_arg + 1], "legacy") == 0)
476 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
477 else if (strcmp(args[*cur_arg + 1], "octet-count") == 0)
478 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
479 else {
480 memprintf(err, "'%s' expects one of 'legacy' or 'octet-count' but got '%s'",
481 args[*cur_arg], args[*cur_arg + 1]);
482 return ERR_ALERT | ERR_FATAL;
483 }
484
485 return 0;
486}
487
488/* Parse the "maxconn" server keyword */
489static int srv_parse_maxconn(char **args, int *cur_arg,
490 struct proxy *curproxy, struct server *newsrv, char **err)
491{
492 newsrv->maxconn = atol(args[*cur_arg + 1]);
493 return 0;
494}
495
496/* Parse the "maxqueue" server keyword */
497static int srv_parse_maxqueue(char **args, int *cur_arg,
498 struct proxy *curproxy, struct server *newsrv, char **err)
499{
500 newsrv->maxqueue = atol(args[*cur_arg + 1]);
501 return 0;
502}
503
504/* Parse the "minconn" server keyword */
505static int srv_parse_minconn(char **args, int *cur_arg,
506 struct proxy *curproxy, struct server *newsrv, char **err)
507{
508 newsrv->minconn = atol(args[*cur_arg + 1]);
509 return 0;
510}
511
Willy Tarreau9c538e02019-01-23 10:21:49 +0100512static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
513{
514 char *arg;
515
516 arg = args[*cur_arg + 1];
517 if (!*arg) {
518 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
519 return ERR_ALERT | ERR_FATAL;
520 }
521 newsrv->max_reuse = atoi(arg);
522
523 return 0;
524}
525
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100526static 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 +0100527{
528 const char *res;
529 char *arg;
530 unsigned int time;
531
532 arg = args[*cur_arg + 1];
533 if (!*arg) {
534 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
535 return ERR_ALERT | ERR_FATAL;
536 }
537 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200538 if (res == PARSE_TIME_OVER) {
539 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
540 args[*cur_arg+1], args[*cur_arg]);
541 return ERR_ALERT | ERR_FATAL;
542 }
543 else if (res == PARSE_TIME_UNDER) {
544 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
545 args[*cur_arg+1], args[*cur_arg]);
546 return ERR_ALERT | ERR_FATAL;
547 }
548 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100549 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
550 *res, args[*cur_arg]);
551 return ERR_ALERT | ERR_FATAL;
552 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100553 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100554
555 return 0;
556}
557
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200558static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
559{
560 char *arg;
561
562 arg = args[*cur_arg + 1];
563 if (!*arg) {
564 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
565 return ERR_ALERT | ERR_FATAL;
566 }
567
568 newsrv->low_idle_conns = atoi(arg);
569 return 0;
570}
571
Olivier Houchard006e3102018-12-10 18:30:32 +0100572static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
573{
574 char *arg;
575
576 arg = args[*cur_arg + 1];
577 if (!*arg) {
578 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
579 return ERR_ALERT | ERR_FATAL;
580 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100581
Olivier Houchard006e3102018-12-10 18:30:32 +0100582 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100583 if ((int)newsrv->max_idle_conns < -1) {
584 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
585 return ERR_ALERT | ERR_FATAL;
586 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100587
588 return 0;
589}
590
Willy Tarreaudff55432012-10-10 17:51:05 +0200591/* parse the "id" server keyword */
592static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
593{
594 struct eb32_node *node;
595
596 if (!*args[*cur_arg + 1]) {
597 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
598 return ERR_ALERT | ERR_FATAL;
599 }
600
601 newsrv->puid = atol(args[*cur_arg + 1]);
602 newsrv->conf.id.key = newsrv->puid;
603
604 if (newsrv->puid <= 0) {
605 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
606 return ERR_ALERT | ERR_FATAL;
607 }
608
609 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
610 if (node) {
611 struct server *target = container_of(node, struct server, conf.id);
612 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
613 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
614 target->id);
615 return ERR_ALERT | ERR_FATAL;
616 }
617
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200618 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200619 return 0;
620}
621
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100622/* Parse the "namespace" server keyword */
623static int srv_parse_namespace(char **args, int *cur_arg,
624 struct proxy *curproxy, struct server *newsrv, char **err)
625{
Willy Tarreaue5733232019-05-22 19:24:06 +0200626#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100627 char *arg;
628
629 arg = args[*cur_arg + 1];
630 if (!*arg) {
631 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
632 return ERR_ALERT | ERR_FATAL;
633 }
634
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100635 if (strcmp(arg, "*") == 0) {
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100636 /* Use the namespace associated with the connection (if present). */
637 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
638 return 0;
639 }
640
641 /*
642 * As this parser may be called several times for the same 'default-server'
643 * object, or for a new 'server' instance deriving from a 'default-server'
644 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
645 */
646 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
647
648 newsrv->netns = netns_store_lookup(arg, strlen(arg));
649 if (!newsrv->netns)
650 newsrv->netns = netns_store_insert(arg);
651
652 if (!newsrv->netns) {
653 memprintf(err, "Cannot open namespace '%s'", arg);
654 return ERR_ALERT | ERR_FATAL;
655 }
656
657 return 0;
658#else
659 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
660 return ERR_ALERT | ERR_FATAL;
661#endif
662}
663
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100664/* Parse the "no-backup" server keyword */
665static int srv_parse_no_backup(char **args, int *cur_arg,
666 struct proxy *curproxy, struct server *newsrv, char **err)
667{
668 newsrv->flags &= ~SRV_F_BACKUP;
669 return 0;
670}
671
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100672
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100673/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200674static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100675{
676 srv->pp_opts &= ~flags;
677 return 0;
678}
679
680/* Parse the "no-send-proxy" server keyword */
681static int srv_parse_no_send_proxy(char **args, int *cur_arg,
682 struct proxy *curproxy, struct server *newsrv, char **err)
683{
684 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
685}
686
687/* Parse the "no-send-proxy-v2" server keyword */
688static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
689 struct proxy *curproxy, struct server *newsrv, char **err)
690{
691 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
692}
693
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200694/* Parse the "no-tfo" server keyword */
695static int srv_parse_no_tfo(char **args, int *cur_arg,
696 struct proxy *curproxy, struct server *newsrv, char **err)
697{
698 newsrv->flags &= ~SRV_F_FASTOPEN;
699 return 0;
700}
701
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100702/* Parse the "non-stick" server keyword */
703static int srv_parse_non_stick(char **args, int *cur_arg,
704 struct proxy *curproxy, struct server *newsrv, char **err)
705{
706 newsrv->flags |= SRV_F_NON_STICK;
707 return 0;
708}
709
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100710/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200711static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100712{
713 srv->pp_opts |= flags;
714 return 0;
715}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200716/* parse the "proto" server keyword */
717static int srv_parse_proto(char **args, int *cur_arg,
718 struct proxy *px, struct server *newsrv, char **err)
719{
720 struct ist proto;
721
722 if (!*args[*cur_arg + 1]) {
723 memprintf(err, "'%s' : missing value", args[*cur_arg]);
724 return ERR_ALERT | ERR_FATAL;
725 }
Tim Duesterhusdcf753a2021-03-04 17:31:47 +0100726 proto = ist(args[*cur_arg + 1]);
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200727 newsrv->mux_proto = get_mux_proto(proto);
728 if (!newsrv->mux_proto) {
729 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
730 return ERR_ALERT | ERR_FATAL;
731 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200732 return 0;
733}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100734
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100735/* parse the "proxy-v2-options" */
736static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
737 struct proxy *px, struct server *newsrv, char **err)
738{
739 char *p, *n;
740 for (p = args[*cur_arg+1]; p; p = n) {
741 n = strchr(p, ',');
742 if (n)
743 *n++ = '\0';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100744 if (strcmp(p, "ssl") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100745 newsrv->pp_opts |= SRV_PP_V2_SSL;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100746 } else if (strcmp(p, "cert-cn") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100747 newsrv->pp_opts |= SRV_PP_V2_SSL;
748 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100749 } else if (strcmp(p, "cert-key") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100750 newsrv->pp_opts |= SRV_PP_V2_SSL;
751 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100752 } else if (strcmp(p, "cert-sig") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100753 newsrv->pp_opts |= SRV_PP_V2_SSL;
754 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100755 } else if (strcmp(p, "ssl-cipher") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100756 newsrv->pp_opts |= SRV_PP_V2_SSL;
757 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100758 } else if (strcmp(p, "authority") == 0) {
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100759 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100760 } else if (strcmp(p, "crc32c") == 0) {
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100761 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100762 } else if (strcmp(p, "unique-id") == 0) {
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100763 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100764 } else
765 goto fail;
766 }
767 return 0;
768 fail:
769 if (err)
770 memprintf(err, "'%s' : proxy v2 option not implemented", p);
771 return ERR_ALERT | ERR_FATAL;
772}
773
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100774/* Parse the "observe" server keyword */
775static int srv_parse_observe(char **args, int *cur_arg,
776 struct proxy *curproxy, struct server *newsrv, char **err)
777{
778 char *arg;
779
780 arg = args[*cur_arg + 1];
781 if (!*arg) {
782 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
783 return ERR_ALERT | ERR_FATAL;
784 }
785
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100786 if (strcmp(arg, "none") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100787 newsrv->observe = HANA_OBS_NONE;
788 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100789 else if (strcmp(arg, "layer4") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100790 newsrv->observe = HANA_OBS_LAYER4;
791 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100792 else if (strcmp(arg, "layer7") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100793 if (curproxy->mode != PR_MODE_HTTP) {
794 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
795 return ERR_ALERT;
796 }
797 newsrv->observe = HANA_OBS_LAYER7;
798 }
799 else {
800 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
801 "but got '%s'\n", args[*cur_arg], arg);
802 return ERR_ALERT | ERR_FATAL;
803 }
804
805 return 0;
806}
807
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100808/* Parse the "on-error" server keyword */
809static int srv_parse_on_error(char **args, int *cur_arg,
810 struct proxy *curproxy, struct server *newsrv, char **err)
811{
812 if (strcmp(args[*cur_arg + 1], "fastinter") == 0)
813 newsrv->onerror = HANA_ONERR_FASTINTER;
814 else if (strcmp(args[*cur_arg + 1], "fail-check") == 0)
815 newsrv->onerror = HANA_ONERR_FAILCHK;
816 else if (strcmp(args[*cur_arg + 1], "sudden-death") == 0)
817 newsrv->onerror = HANA_ONERR_SUDDTH;
818 else if (strcmp(args[*cur_arg + 1], "mark-down") == 0)
819 newsrv->onerror = HANA_ONERR_MARKDWN;
820 else {
821 memprintf(err, "'%s' expects one of 'fastinter', "
822 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'",
823 args[*cur_arg], args[*cur_arg + 1]);
824 return ERR_ALERT | ERR_FATAL;
825 }
826
827 return 0;
828}
829
830/* Parse the "on-marked-down" server keyword */
831static int srv_parse_on_marked_down(char **args, int *cur_arg,
832 struct proxy *curproxy, struct server *newsrv, char **err)
833{
834 if (strcmp(args[*cur_arg + 1], "shutdown-sessions") == 0)
835 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
836 else {
837 memprintf(err, "'%s' expects 'shutdown-sessions' but got '%s'",
838 args[*cur_arg], args[*cur_arg + 1]);
839 return ERR_ALERT | ERR_FATAL;
840 }
841
842 return 0;
843}
844
845/* Parse the "on-marked-up" server keyword */
846static int srv_parse_on_marked_up(char **args, int *cur_arg,
847 struct proxy *curproxy, struct server *newsrv, char **err)
848{
849 if (strcmp(args[*cur_arg + 1], "shutdown-backup-sessions") == 0)
850 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
851 else {
852 memprintf(err, "'%s' expects 'shutdown-backup-sessions' but got '%s'",
853 args[*cur_arg], args[*cur_arg + 1]);
854 return ERR_ALERT | ERR_FATAL;
855 }
856
857 return 0;
858}
859
Frédéric Lécaille16186232017-03-14 16:42:49 +0100860/* Parse the "redir" server keyword */
861static int srv_parse_redir(char **args, int *cur_arg,
862 struct proxy *curproxy, struct server *newsrv, char **err)
863{
864 char *arg;
865
866 arg = args[*cur_arg + 1];
867 if (!*arg) {
868 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
869 return ERR_ALERT | ERR_FATAL;
870 }
871
872 free(newsrv->rdr_pfx);
873 newsrv->rdr_pfx = strdup(arg);
874 newsrv->rdr_len = strlen(arg);
875
876 return 0;
877}
878
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100879/* Parse the "resolvers" server keyword */
880static int srv_parse_resolvers(char **args, int *cur_arg,
881 struct proxy *curproxy, struct server *newsrv, char **err)
882{
883 free(newsrv->resolvers_id);
884 newsrv->resolvers_id = strdup(args[*cur_arg + 1]);
885 return 0;
886}
887
888/* Parse the "resolve-net" server keyword */
889static int srv_parse_resolve_net(char **args, int *cur_arg,
890 struct proxy *curproxy, struct server *newsrv, char **err)
891{
892 char *p, *e;
893 unsigned char mask;
894 struct resolv_options *opt;
895
896 if (!args[*cur_arg + 1] || args[*cur_arg + 1][0] == '\0') {
897 memprintf(err, "'%s' expects a list of networks.",
898 args[*cur_arg]);
899 return ERR_ALERT | ERR_FATAL;
900 }
901
902 opt = &newsrv->resolv_opts;
903
904 /* Split arguments by comma, and convert it from ipv4 or ipv6
905 * string network in in_addr or in6_addr.
906 */
907 p = args[*cur_arg + 1];
908 e = p;
909 while (*p != '\0') {
910 /* If no room available, return error. */
911 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
912 memprintf(err, "'%s' exceed %d networks.",
913 args[*cur_arg], SRV_MAX_PREF_NET);
914 return ERR_ALERT | ERR_FATAL;
915 }
916 /* look for end or comma. */
917 while (*e != ',' && *e != '\0')
918 e++;
919 if (*e == ',') {
920 *e = '\0';
921 e++;
922 }
923 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
924 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
925 /* Try to convert input string from ipv4 or ipv6 network. */
926 opt->pref_net[opt->pref_net_nb].family = AF_INET;
927 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
928 &mask)) {
929 /* Try to convert input string from ipv6 network. */
930 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
931 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
932 } else {
933 /* All network conversions fail, return error. */
934 memprintf(err, "'%s' invalid network '%s'.",
935 args[*cur_arg], p);
936 return ERR_ALERT | ERR_FATAL;
937 }
938 opt->pref_net_nb++;
939 p = e;
940 }
941
942 return 0;
943}
944
945/* Parse the "resolve-opts" server keyword */
946static int srv_parse_resolve_opts(char **args, int *cur_arg,
947 struct proxy *curproxy, struct server *newsrv, char **err)
948{
949 char *p, *end;
950
951 for (p = args[*cur_arg + 1]; *p; p = end) {
952 /* cut on next comma */
953 for (end = p; *end && *end != ','; end++);
954 if (*end)
955 *(end++) = 0;
956
957 if (strcmp(p, "allow-dup-ip") == 0) {
958 newsrv->resolv_opts.accept_duplicate_ip = 1;
959 }
960 else if (strcmp(p, "ignore-weight") == 0) {
961 newsrv->resolv_opts.ignore_weight = 1;
962 }
963 else if (strcmp(p, "prevent-dup-ip") == 0) {
964 newsrv->resolv_opts.accept_duplicate_ip = 0;
965 }
966 else {
967 memprintf(err, "'%s' : unknown resolve-opts option '%s', supported methods are 'allow-dup-ip', 'ignore-weight', and 'prevent-dup-ip'.",
968 args[*cur_arg], p);
969 return ERR_ALERT | ERR_FATAL;
970 }
971 }
972
973 return 0;
974}
975
976/* Parse the "resolve-prefer" server keyword */
977static int srv_parse_resolve_prefer(char **args, int *cur_arg,
978 struct proxy *curproxy, struct server *newsrv, char **err)
979{
980 if (strcmp(args[*cur_arg + 1], "ipv4") == 0)
981 newsrv->resolv_opts.family_prio = AF_INET;
982 else if (strcmp(args[*cur_arg + 1], "ipv6") == 0)
983 newsrv->resolv_opts.family_prio = AF_INET6;
984 else {
985 memprintf(err, "'%s' expects either ipv4 or ipv6 as argument.",
986 args[*cur_arg]);
987 return ERR_ALERT | ERR_FATAL;
988 }
989
990 return 0;
991}
992
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100993/* Parse the "send-proxy" server keyword */
994static int srv_parse_send_proxy(char **args, int *cur_arg,
995 struct proxy *curproxy, struct server *newsrv, char **err)
996{
997 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
998}
999
1000/* Parse the "send-proxy-v2" server keyword */
1001static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
1002 struct proxy *curproxy, struct server *newsrv, char **err)
1003{
1004 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
1005}
1006
Amaury Denoyelle587b71e2021-03-10 16:36:02 +01001007/* Parse the "slowstart" server keyword */
1008static int srv_parse_slowstart(char **args, int *cur_arg,
1009 struct proxy *curproxy, struct server *newsrv, char **err)
1010{
1011 /* slowstart is stored in seconds */
1012 unsigned int val;
1013 const char *time_err = parse_time_err(args[*cur_arg + 1], &val, TIME_UNIT_MS);
1014
1015 if (time_err == PARSE_TIME_OVER) {
1016 memprintf(err, "overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
1017 args[*cur_arg+1], args[*cur_arg], newsrv->id);
1018 return ERR_ALERT | ERR_FATAL;
1019 }
1020 else if (time_err == PARSE_TIME_UNDER) {
1021 memprintf(err, "underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
1022 args[*cur_arg+1], args[*cur_arg], newsrv->id);
1023 return ERR_ALERT | ERR_FATAL;
1024 }
1025 else if (time_err) {
1026 memprintf(err, "unexpected character '%c' in 'slowstart' argument of server %s.",
1027 *time_err, newsrv->id);
1028 return ERR_ALERT | ERR_FATAL;
1029 }
1030 newsrv->slowstart = (val + 999) / 1000;
1031
1032 return 0;
1033}
Frédéric Lécailledba97072017-03-17 15:33:50 +01001034
1035/* Parse the "source" server keyword */
1036static int srv_parse_source(char **args, int *cur_arg,
1037 struct proxy *curproxy, struct server *newsrv, char **err)
1038{
1039 char *errmsg;
1040 int port_low, port_high;
1041 struct sockaddr_storage *sk;
Frédéric Lécailledba97072017-03-17 15:33:50 +01001042
1043 errmsg = NULL;
1044
1045 if (!*args[*cur_arg + 1]) {
1046 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
1047 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
1048 goto err;
1049 }
1050
1051 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001052 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
1053 &errmsg, NULL, NULL,
1054 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 +01001055 if (!sk) {
1056 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
1057 goto err;
1058 }
1059
Frédéric Lécailledba97072017-03-17 15:33:50 +01001060 newsrv->conn_src.opts |= CO_SRC_BIND;
1061 newsrv->conn_src.source_addr = *sk;
1062
1063 if (port_low != port_high) {
1064 int i;
1065
Frédéric Lécailledba97072017-03-17 15:33:50 +01001066 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
Remi Tricot-Le Bretondc187912021-05-12 09:44:06 +02001067 if (!newsrv->conn_src.sport_range) {
1068 ha_alert("Server '%s': Out of memory (sport_range)\n", args[0]);
1069 goto err;
1070 }
Frédéric Lécailledba97072017-03-17 15:33:50 +01001071 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
1072 newsrv->conn_src.sport_range->ports[i] = port_low + i;
1073 }
1074
1075 *cur_arg += 2;
1076 while (*(args[*cur_arg])) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001077 if (strcmp(args[*cur_arg], "usesrc") == 0) { /* address to use outside */
Frédéric Lécailledba97072017-03-17 15:33:50 +01001078#if defined(CONFIG_HAP_TRANSPARENT)
1079 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001080 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
1081 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +01001082 goto err;
1083 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001084 if (strcmp(args[*cur_arg + 1], "client") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +01001085 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1086 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
1087 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001088 else if (strcmp(args[*cur_arg + 1], "clientip") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +01001089 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1090 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
1091 }
1092 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
1093 char *name, *end;
1094
1095 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +01001096 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001097 name++;
1098
1099 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +01001100 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +01001101 end++;
1102
1103 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1104 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
1105 free(newsrv->conn_src.bind_hdr_name);
1106 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
Remi Tricot-Le Bretondc187912021-05-12 09:44:06 +02001107 if (!newsrv->conn_src.bind_hdr_name) {
1108 ha_alert("Server '%s': Out of memory (bind_hdr_name)\n", args[0]);
1109 goto err;
1110 }
Frédéric Lécailledba97072017-03-17 15:33:50 +01001111 newsrv->conn_src.bind_hdr_len = end - name;
1112 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
1113 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
1114 newsrv->conn_src.bind_hdr_occ = -1;
1115
1116 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +01001117 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001118 end++;
1119 if (*end == ',') {
1120 end++;
1121 name = end;
1122 if (*end == '-')
1123 end++;
Willy Tarreau90807112020-02-25 08:16:33 +01001124 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001125 end++;
1126 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
1127 }
1128
1129 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001130 ha_alert("usesrc hdr_ip(name,num) does not support negative"
1131 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001132 goto err;
1133 }
1134 }
1135 else {
1136 struct sockaddr_storage *sk;
1137 int port1, port2;
1138
1139 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001140 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, NULL, NULL,
1141 &errmsg, NULL, NULL,
1142 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001143 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001144 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001145 goto err;
1146 }
1147
Frédéric Lécailledba97072017-03-17 15:33:50 +01001148 newsrv->conn_src.tproxy_addr = *sk;
1149 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
1150 }
1151 global.last_checks |= LSTCHK_NETADM;
1152 *cur_arg += 2;
1153 continue;
1154#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001155 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 +01001156 goto err;
1157#endif /* defined(CONFIG_HAP_TRANSPARENT) */
1158 } /* "usesrc" */
1159
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001160 if (strcmp(args[*cur_arg], "interface") == 0) { /* specifically bind to this interface */
Frédéric Lécailledba97072017-03-17 15:33:50 +01001161#ifdef SO_BINDTODEVICE
1162 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001163 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001164 goto err;
1165 }
1166 free(newsrv->conn_src.iface_name);
1167 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
1168 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
1169 global.last_checks |= LSTCHK_NETADM;
1170#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001171 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001172 goto err;
1173#endif
1174 *cur_arg += 2;
1175 continue;
1176 }
1177 /* this keyword in not an option of "source" */
1178 break;
1179 } /* while */
1180
1181 return 0;
1182
1183 err:
1184 free(errmsg);
1185 return ERR_ALERT | ERR_FATAL;
1186}
1187
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001188/* Parse the "stick" server keyword */
1189static int srv_parse_stick(char **args, int *cur_arg,
1190 struct proxy *curproxy, struct server *newsrv, char **err)
1191{
1192 newsrv->flags &= ~SRV_F_NON_STICK;
1193 return 0;
1194}
1195
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001196/* Parse the "track" server keyword */
1197static int srv_parse_track(char **args, int *cur_arg,
1198 struct proxy *curproxy, struct server *newsrv, char **err)
1199{
1200 char *arg;
1201
1202 arg = args[*cur_arg + 1];
1203 if (!*arg) {
1204 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
1205 return ERR_ALERT | ERR_FATAL;
1206 }
1207
1208 free(newsrv->trackit);
1209 newsrv->trackit = strdup(arg);
1210
1211 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001212}
1213
1214/* Parse the "socks4" server keyword */
1215static int srv_parse_socks4(char **args, int *cur_arg,
1216 struct proxy *curproxy, struct server *newsrv, char **err)
1217{
1218 char *errmsg;
1219 int port_low, port_high;
1220 struct sockaddr_storage *sk;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001221
1222 errmsg = NULL;
1223
1224 if (!*args[*cur_arg + 1]) {
1225 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
1226 goto err;
1227 }
1228
1229 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001230 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
1231 &errmsg, NULL, NULL,
1232 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_CONNECT);
Alexander Liu2a54bb72019-05-22 19:44:48 +08001233 if (!sk) {
1234 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
1235 goto err;
1236 }
1237
Alexander Liu2a54bb72019-05-22 19:44:48 +08001238 newsrv->flags |= SRV_F_SOCKS4_PROXY;
1239 newsrv->socks4_addr = *sk;
1240
Alexander Liu2a54bb72019-05-22 19:44:48 +08001241 return 0;
1242
1243 err:
1244 free(errmsg);
1245 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001246}
1247
Frédéric Lécailledba97072017-03-17 15:33:50 +01001248
Willy Tarreau034c88c2017-01-23 23:36:45 +01001249/* parse the "tfo" server keyword */
1250static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1251{
1252 newsrv->flags |= SRV_F_FASTOPEN;
1253 return 0;
1254}
1255
Amaury Denoyelle587b71e2021-03-10 16:36:02 +01001256/* parse the "usesrc" server keyword */
1257static int srv_parse_usesrc(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1258{
1259 memprintf(err, "'%s' only allowed after a '%s' statement.",
1260 "usesrc", "source");
1261 return ERR_ALERT | ERR_FATAL;
1262}
1263
1264/* parse the "weight" server keyword */
1265static int srv_parse_weight(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1266{
1267 int w;
1268
1269 w = atol(args[*cur_arg + 1]);
1270 if (w < 0 || w > SRV_UWGHT_MAX) {
1271 memprintf(err, "weight of server %s is not within 0 and %d (%d).",
1272 newsrv->id, SRV_UWGHT_MAX, w);
1273 return ERR_ALERT | ERR_FATAL;
1274 }
1275 newsrv->uweight = newsrv->iweight = w;
1276
1277 return 0;
1278}
1279
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001280/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +02001281 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001282 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001283 *
1284 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001285 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001286void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001287{
Willy Tarreau751153e2021-02-17 13:33:24 +01001288 struct stream *stream;
1289 struct mt_list *elt1, elt2;
Willy Tarreaud4e78d82021-03-04 10:47:54 +01001290 int thr;
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001291
Willy Tarreaud4e78d82021-03-04 10:47:54 +01001292 for (thr = 0; thr < global.nbthread; thr++)
1293 mt_list_for_each_entry_safe(stream, &srv->per_thr[thr].streams, by_srv, elt1, elt2)
1294 if (stream->srv_conn == srv)
1295 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001296}
1297
1298/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +02001299 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001300 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001301 *
1302 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001303 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001304void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001305{
1306 struct server *srv;
1307
1308 for (srv = px->srv; srv != NULL; srv = srv->next)
1309 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +02001310 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001311}
1312
Willy Tarreaubda92272014-05-20 21:55:30 +02001313/* Appends some information to a message string related to a server going UP or
1314 * DOWN. If both <forced> and <reason> are null and the server tracks another
1315 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +02001316 * If <check> is non-null, an entire string describing the check result will be
1317 * appended after a comma and a space (eg: to report some information from the
1318 * check that changed the state). In the other case, the string will be built
1319 * using the check results stored into the struct server if present.
1320 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +02001321 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001322 *
1323 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001324 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001325void srv_append_status(struct buffer *msg, struct server *s,
1326 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001327{
Emeric Brun5a133512017-10-19 14:42:30 +02001328 short status = s->op_st_chg.status;
1329 short code = s->op_st_chg.code;
1330 long duration = s->op_st_chg.duration;
1331 char *desc = s->op_st_chg.reason;
1332
1333 if (check) {
1334 status = check->status;
1335 code = check->code;
1336 duration = check->duration;
1337 desc = check->desc;
1338 }
1339
1340 if (status != -1) {
1341 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
1342
1343 if (status >= HCHK_STATUS_L57DATA)
1344 chunk_appendf(msg, ", code: %d", code);
1345
1346 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001347 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +02001348
1349 chunk_appendf(msg, ", info: \"");
1350
1351 chunk_initlen(&src, desc, 0, strlen(desc));
1352 chunk_asciiencode(msg, &src, '"');
1353
1354 chunk_appendf(msg, "\"");
1355 }
1356
1357 if (duration >= 0)
1358 chunk_appendf(msg, ", check duration: %ldms", duration);
1359 }
1360 else if (desc && *desc) {
1361 chunk_appendf(msg, ", %s", desc);
1362 }
1363 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +02001364 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +02001365 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001366
1367 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +02001368 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001369 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
1370 " %d sessions active, %d requeued, %d remaining in queue",
1371 s->proxy->srv_act, s->proxy->srv_bck,
1372 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
1373 s->cur_sess, xferred, s->nbpend);
1374 else
1375 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
1376 " %d sessions requeued, %d total in queue",
1377 s->proxy->srv_act, s->proxy->srv_bck,
1378 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
1379 xferred, s->nbpend);
1380 }
1381}
1382
Emeric Brun5a133512017-10-19 14:42:30 +02001383/* Marks server <s> down, regardless of its checks' statuses. The server is
1384 * registered in a list to postpone the counting of the remaining servers on
1385 * the proxy and transfers queued streams whenever possible to other servers at
1386 * a sync point. Maintenance servers are ignored. It stores the <reason> if
1387 * non-null as the reason for going down or the available data from the check
1388 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001389 *
1390 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001391 */
Emeric Brun5a133512017-10-19 14:42:30 +02001392void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001393{
1394 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001395
Emeric Brun64cc49c2017-10-03 14:46:45 +02001396 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001397 return;
1398
Emeric Brun52a91d32017-08-31 14:41:55 +02001399 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001400 *s->op_st_chg.reason = 0;
1401 s->op_st_chg.status = -1;
1402 if (reason) {
1403 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1404 }
1405 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001406 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001407 s->op_st_chg.code = check->code;
1408 s->op_st_chg.status = check->status;
1409 s->op_st_chg.duration = check->duration;
1410 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001411
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001412 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001413 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001414
Emeric Brun9f0b4582017-10-23 14:39:51 +02001415 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001416 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001417 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001418 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001419 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001420}
1421
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001422/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001423 * in maintenance. The server is registered in a list to postpone the counting
1424 * of the remaining servers on the proxy and tries to grab requests from the
1425 * proxy at a sync point. Maintenance servers are ignored. It stores the
1426 * <reason> if non-null as the reason for going down or the available data
1427 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001428 *
1429 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001430 */
Emeric Brun5a133512017-10-19 14:42:30 +02001431void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001432{
1433 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001434
Emeric Brun64cc49c2017-10-03 14:46:45 +02001435 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001436 return;
1437
Emeric Brun52a91d32017-08-31 14:41:55 +02001438 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001439 return;
1440
Emeric Brun52a91d32017-08-31 14:41:55 +02001441 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001442 *s->op_st_chg.reason = 0;
1443 s->op_st_chg.status = -1;
1444 if (reason) {
1445 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1446 }
1447 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001448 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001449 s->op_st_chg.code = check->code;
1450 s->op_st_chg.status = check->status;
1451 s->op_st_chg.duration = check->duration;
1452 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001453
Emeric Brun64cc49c2017-10-03 14:46:45 +02001454 if (s->slowstart <= 0)
1455 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001456
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001457 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001458 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001459
Emeric Brun9f0b4582017-10-23 14:39:51 +02001460 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001461 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001462 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001463 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001464 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001465}
1466
Willy Tarreau8eb77842014-05-21 13:54:57 +02001467/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001468 * isn't in maintenance. The server is registered in a list to postpone the
1469 * counting of the remaining servers on the proxy and tries to grab requests
1470 * from the proxy. Maintenance servers are ignored. It stores the
1471 * <reason> if non-null as the reason for going down or the available data
1472 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001473 * up. Note that it makes use of the trash to build the log strings, so <reason>
1474 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001475 *
1476 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001477 */
Emeric Brun5a133512017-10-19 14:42:30 +02001478void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001479{
1480 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001481
Emeric Brun64cc49c2017-10-03 14:46:45 +02001482 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001483 return;
1484
Emeric Brun52a91d32017-08-31 14:41:55 +02001485 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001486 return;
1487
Emeric Brun52a91d32017-08-31 14:41:55 +02001488 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001489 *s->op_st_chg.reason = 0;
1490 s->op_st_chg.status = -1;
1491 if (reason) {
1492 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1493 }
1494 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001495 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001496 s->op_st_chg.code = check->code;
1497 s->op_st_chg.status = check->status;
1498 s->op_st_chg.duration = check->duration;
1499 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001500
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001501 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001502 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001503
Emeric Brun9f0b4582017-10-23 14:39:51 +02001504 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001505 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001506 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001507 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001508 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001509}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001510
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001511/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1512 * enforce either maint mode or drain mode. It is not allowed to set more than
1513 * one flag at once. The equivalent "inherited" flag is propagated to all
1514 * tracking servers. Maintenance mode disables health checks (but not agent
1515 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001516 * is done. If <cause> is non-null, it will be displayed at the end of the log
1517 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001518 *
1519 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001520 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001521void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001522{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001523 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001524
1525 if (!mode)
1526 return;
1527
1528 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001529 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001530 return;
1531
Emeric Brun52a91d32017-08-31 14:41:55 +02001532 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001533 if (cause)
1534 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1535
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001536 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001537 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001538
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001539 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001540 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1541 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001542 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001543
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001544 /* compute the inherited flag to propagate */
1545 if (mode & SRV_ADMF_MAINT)
1546 mode = SRV_ADMF_IMAINT;
1547 else if (mode & SRV_ADMF_DRAIN)
1548 mode = SRV_ADMF_IDRAIN;
1549
Emeric Brun9f0b4582017-10-23 14:39:51 +02001550 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001551 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001552 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001553 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001554 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001555}
1556
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001557/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1558 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1559 * than one flag at once. The equivalent "inherited" flag is propagated to all
1560 * tracking servers. Leaving maintenance mode re-enables health checks. When
1561 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001562 *
1563 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001564 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001565void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001566{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001567 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001568
1569 if (!mode)
1570 return;
1571
1572 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001573 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001574 return;
1575
Emeric Brun52a91d32017-08-31 14:41:55 +02001576 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001577
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001578 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001579 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001580
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001581 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001582 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1583 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001584 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001585
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001586 if (mode & SRV_ADMF_MAINT)
1587 mode = SRV_ADMF_IMAINT;
1588 else if (mode & SRV_ADMF_DRAIN)
1589 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001590
Emeric Brun9f0b4582017-10-23 14:39:51 +02001591 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001592 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001593 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001594 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001595 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001596}
1597
Willy Tarreau757478e2016-11-03 19:22:19 +01001598/* principle: propagate maint and drain to tracking servers. This is useful
1599 * upon startup so that inherited states are correct.
1600 */
1601static void srv_propagate_admin_state(struct server *srv)
1602{
1603 struct server *srv2;
1604
1605 if (!srv->trackers)
1606 return;
1607
1608 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001609 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001610 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001611 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001612
Emeric Brun52a91d32017-08-31 14:41:55 +02001613 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001614 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001615 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001616 }
1617}
1618
1619/* Compute and propagate the admin states for all servers in proxy <px>.
1620 * Only servers *not* tracking another one are considered, because other
1621 * ones will be handled when the server they track is visited.
1622 */
1623void srv_compute_all_admin_states(struct proxy *px)
1624{
1625 struct server *srv;
1626
1627 for (srv = px->srv; srv; srv = srv->next) {
1628 if (srv->track)
1629 continue;
1630 srv_propagate_admin_state(srv);
1631 }
1632}
1633
Willy Tarreaudff55432012-10-10 17:51:05 +02001634/* Note: must not be declared <const> as its list will be overwritten.
1635 * Please take care of keeping this list alphabetically sorted, doing so helps
1636 * all code contributors.
1637 * Optional keywords are also declared with a NULL ->parse() function so that
1638 * the config parser can report an appropriate error when a known keyword was
1639 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001640 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001641 */
1642static struct srv_kw_list srv_kws = { "ALL", { }, {
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001643 { "backup", srv_parse_backup, 0, 1, 1 }, /* Flag as backup server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001644 { "cookie", srv_parse_cookie, 1, 1, 0 }, /* Assign a cookie to the server */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001645 { "disabled", srv_parse_disabled, 0, 1, 1 }, /* Start the server in 'disabled' state */
1646 { "enabled", srv_parse_enabled, 0, 1, 1 }, /* Start the server in 'enabled' state */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001647 { "error-limit", srv_parse_error_limit, 1, 1, 0 }, /* Configure the consecutive count of check failures to consider a server on error */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001648 { "id", srv_parse_id, 1, 0, 1 }, /* set id# of server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001649 { "init-addr", srv_parse_init_addr, 1, 1, 0 }, /* */
1650 { "log-proto", srv_parse_log_proto, 1, 1, 0 }, /* Set the protocol for event messages, only relevant in a ring section */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001651 { "maxconn", srv_parse_maxconn, 1, 1, 1 }, /* Set the max number of concurrent connection */
1652 { "maxqueue", srv_parse_maxqueue, 1, 1, 1 }, /* Set the max number of connection to put in queue */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001653 { "max-reuse", srv_parse_max_reuse, 1, 1, 0 }, /* Set the max number of requests on a connection, -1 means unlimited */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001654 { "minconn", srv_parse_minconn, 1, 1, 1 }, /* Enable a dynamic maxconn limit */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001655 { "namespace", srv_parse_namespace, 1, 1, 0 }, /* Namespace the server socket belongs to (if supported) */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001656 { "no-backup", srv_parse_no_backup, 0, 1, 1 }, /* Flag as non-backup server */
1657 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1, 1 }, /* Disable use of PROXY V1 protocol */
1658 { "no-send-proxy-v2", srv_parse_no_send_proxy_v2, 0, 1, 1 }, /* Disable use of PROXY V2 protocol */
1659 { "no-tfo", srv_parse_no_tfo, 0, 1, 1 }, /* Disable use of TCP Fast Open */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001660 { "non-stick", srv_parse_non_stick, 0, 1, 0 }, /* Disable stick-table persistence */
1661 { "observe", srv_parse_observe, 1, 1, 0 }, /* Enables health adjusting based on observing communication with the server */
1662 { "on-error", srv_parse_on_error, 1, 1, 0 }, /* Configure the action on check failure */
1663 { "on-marked-down", srv_parse_on_marked_down, 1, 1, 0 }, /* Configure the action when a server is marked down */
1664 { "on-marked-up", srv_parse_on_marked_up, 1, 1, 0 }, /* Configure the action when a server is marked up */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001665 { "pool-low-conn", srv_parse_pool_low_conn, 1, 1, 1 }, /* Set the min number of orphan idle connecbefore being allowed to pick from other threads */
1666 { "pool-max-conn", srv_parse_pool_max_conn, 1, 1, 1 }, /* Set the max number of orphan idle connections, -1 means unlimited */
1667 { "pool-purge-delay", srv_parse_pool_purge_delay, 1, 1, 1 }, /* Set the time before we destroy orphan idle connections, defaults to 1s */
Amaury Denoyelle30467232021-03-12 18:03:27 +01001668 { "proto", srv_parse_proto, 1, 1, 1 }, /* Set the proto to use for all outgoing connections */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001669 { "proxy-v2-options", srv_parse_proxy_v2_options, 1, 1, 1 }, /* options for send-proxy-v2 */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001670 { "redir", srv_parse_redir, 1, 1, 0 }, /* Enable redirection mode */
Ilya Shipitsinba13f162021-03-19 22:21:44 +05001671 { "resolve-net", srv_parse_resolve_net, 1, 1, 0 }, /* Set the preferred network range for name resolution */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001672 { "resolve-opts", srv_parse_resolve_opts, 1, 1, 0 }, /* Set options for name resolution */
Ilya Shipitsinba13f162021-03-19 22:21:44 +05001673 { "resolve-prefer", srv_parse_resolve_prefer, 1, 1, 0 }, /* Set the preferred family for name resolution */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001674 { "resolvers", srv_parse_resolvers, 1, 1, 0 }, /* Configure the resolver to use for name resolution */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001675 { "send-proxy", srv_parse_send_proxy, 0, 1, 1 }, /* Enforce use of PROXY V1 protocol */
1676 { "send-proxy-v2", srv_parse_send_proxy_v2, 0, 1, 1 }, /* Enforce use of PROXY V2 protocol */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001677 { "slowstart", srv_parse_slowstart, 1, 1, 0 }, /* Set the warm-up timer for a previously failed server */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001678 { "source", srv_parse_source, -1, 1, 1 }, /* Set the source address to be used to connect to the server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001679 { "stick", srv_parse_stick, 0, 1, 0 }, /* Enable stick-table persistence */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001680 { "tfo", srv_parse_tfo, 0, 1, 1 }, /* enable TCP Fast Open of server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001681 { "track", srv_parse_track, 1, 1, 0 }, /* Set the current state of the server, tracking another one */
1682 { "socks4", srv_parse_socks4, 1, 1, 0 }, /* Set the socks4 proxy of the server*/
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001683 { "usesrc", srv_parse_usesrc, 0, 1, 1 }, /* safe-guard against usesrc without preceding <source> keyword */
1684 { "weight", srv_parse_weight, 1, 1, 1 }, /* Set the load-balancing weight */
Willy Tarreaudff55432012-10-10 17:51:05 +02001685 { NULL, NULL, 0 },
1686}};
1687
Willy Tarreau0108d902018-11-25 19:14:37 +01001688INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001689
Willy Tarreau004e0452013-11-21 11:22:01 +01001690/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001691 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001692 * state is automatically disabled if the time is elapsed. If <must_update> is
1693 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001694 *
1695 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001696 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001697void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001698{
1699 struct proxy *px = sv->proxy;
1700 unsigned w;
1701
1702 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1703 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001704 if (sv->next_state == SRV_ST_STARTING)
1705 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001706 }
1707
1708 /* We must take care of not pushing the server to full throttle during slow starts.
1709 * It must also start immediately, at least at the minimal step when leaving maintenance.
1710 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001711 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001712 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1713 else
1714 w = px->lbprm.wdiv;
1715
Emeric Brun52a91d32017-08-31 14:41:55 +02001716 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001717
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001718 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001719 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001720 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001721}
1722
Willy Tarreaubaaee002006-06-26 02:48:02 +02001723/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001724 * Parses weight_str and configures sv accordingly.
1725 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001726 *
1727 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001728 */
1729const char *server_parse_weight_change_request(struct server *sv,
1730 const char *weight_str)
1731{
1732 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001733 long int w;
1734 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001735
1736 px = sv->proxy;
1737
1738 /* if the weight is terminated with '%', it is set relative to
1739 * the initial weight, otherwise it is absolute.
1740 */
1741 if (!*weight_str)
1742 return "Require <weight> or <weight%>.\n";
1743
Simon Hormanb796afa2013-02-12 10:45:53 +09001744 w = strtol(weight_str, &end, 10);
1745 if (end == weight_str)
1746 return "Empty weight string empty or preceded by garbage";
1747 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001748 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001749 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001750 /* Avoid integer overflow */
1751 if (w > 25600)
1752 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001753 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001754 if (w > 256)
1755 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001756 }
1757 else if (w < 0 || w > 256)
1758 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001759 else if (end[0] != '\0')
1760 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001761
1762 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1763 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1764
1765 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001766 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001767
1768 return NULL;
1769}
1770
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001771/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001772 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1773 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001774 * Returns:
1775 * - error string on error
1776 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001777 *
1778 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001779 */
1780const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001781 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001782{
1783 unsigned char ip[INET6_ADDRSTRLEN];
1784
1785 if (inet_pton(AF_INET6, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001786 srv_update_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001787 return NULL;
1788 }
1789 if (inet_pton(AF_INET, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001790 srv_update_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001791 return NULL;
1792 }
1793
1794 return "Could not understand IP address format.\n";
1795}
1796
Willy Tarreau46b7f532018-08-21 11:54:26 +02001797/*
1798 * Must be called with the server lock held.
1799 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001800const char *server_parse_maxconn_change_request(struct server *sv,
1801 const char *maxconn_str)
1802{
1803 long int v;
1804 char *end;
1805
1806 if (!*maxconn_str)
1807 return "Require <maxconn>.\n";
1808
1809 v = strtol(maxconn_str, &end, 10);
1810 if (end == maxconn_str)
1811 return "maxconn string empty or preceded by garbage";
1812 else if (end[0] != '\0')
1813 return "Trailing garbage in maxconn string";
1814
1815 if (sv->maxconn == sv->minconn) { // static maxconn
1816 sv->maxconn = sv->minconn = v;
1817 } else { // dynamic maxconn
1818 sv->maxconn = v;
1819 }
1820
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02001821 /* server_parse_maxconn_change_request requires the server lock held.
1822 * Specify it to process_srv_queue to prevent a deadlock.
1823 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001824 if (may_dequeue_tasks(sv, sv->proxy))
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02001825 process_srv_queue(sv, 1);
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001826
1827 return NULL;
1828}
1829
William Lallemand71048532021-10-20 13:28:41 +02001830#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001831static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1832 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001833{
1834 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001835 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001836 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001837 NULL,
1838 };
1839
1840 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001841 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001842
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001843 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001844}
1845
1846static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1847{
1848 struct sample_expr *expr;
1849
1850 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 +01001851 if (!expr) {
1852 memprintf(err, "error detected while parsing sni expression : %s", *err);
1853 return ERR_ALERT | ERR_FATAL;
1854 }
1855
1856 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1857 memprintf(err, "error detected while parsing sni expression : "
1858 " fetch method '%s' extracts information from '%s', "
1859 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001860 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001861 return ERR_ALERT | ERR_FATAL;
1862 }
1863
1864 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1865 release_sample_expr(newsrv->ssl_ctx.sni);
1866 newsrv->ssl_ctx.sni = expr;
1867
1868 return 0;
1869}
William Lallemand71048532021-10-20 13:28:41 +02001870#endif
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001871
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001872static 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 +01001873{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001874 char *msg = "error encountered while processing ";
1875 char *quote = "'";
1876 char *token = args[cur_arg];
1877
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001878 if (err && *err) {
1879 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001880 msg = *err;
1881 quote = "";
1882 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001883 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001884
1885 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
1886 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1887 file, linenum, args[0], args[1],
1888 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001889 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001890 ha_alert("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1891 file, linenum, args[0], args[1],
1892 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001893}
1894
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001895static void srv_conn_src_sport_range_cpy(struct server *srv,
1896 struct server *src)
1897{
1898 int range_sz;
1899
1900 range_sz = src->conn_src.sport_range->size;
1901 if (range_sz > 0) {
1902 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1903 if (srv->conn_src.sport_range != NULL) {
1904 int i;
1905
1906 for (i = 0; i < range_sz; i++) {
1907 srv->conn_src.sport_range->ports[i] =
1908 src->conn_src.sport_range->ports[i];
1909 }
1910 }
1911 }
1912}
1913
1914/*
1915 * Copy <src> server connection source settings to <srv> server everything needed.
1916 */
1917static void srv_conn_src_cpy(struct server *srv, struct server *src)
1918{
1919 srv->conn_src.opts = src->conn_src.opts;
1920 srv->conn_src.source_addr = src->conn_src.source_addr;
1921
1922 /* Source port range copy. */
1923 if (src->conn_src.sport_range != NULL)
1924 srv_conn_src_sport_range_cpy(srv, src);
1925
1926#ifdef CONFIG_HAP_TRANSPARENT
1927 if (src->conn_src.bind_hdr_name != NULL) {
1928 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1929 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1930 }
1931 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1932 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1933#endif
1934 if (src->conn_src.iface_name != NULL)
1935 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1936}
1937
1938/*
1939 * Copy <src> server SSL settings to <srv> server allocating
1940 * everything needed.
1941 */
1942#if defined(USE_OPENSSL)
1943static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1944{
1945 if (src->ssl_ctx.ca_file != NULL)
1946 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1947 if (src->ssl_ctx.crl_file != NULL)
1948 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001949
1950 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1951
Remi Tricot-Le Breton3b0f3e02021-07-13 18:28:22 +02001952 srv->ssl_ctx.ctx = src->ssl_ctx.ctx;
1953
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001954 if (src->ssl_ctx.verify_host != NULL)
1955 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1956 if (src->ssl_ctx.ciphers != NULL)
1957 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02001958 if (src->ssl_ctx.options)
1959 srv->ssl_ctx.options = src->ssl_ctx.options;
1960 if (src->ssl_ctx.methods.flags)
1961 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
1962 if (src->ssl_ctx.methods.min)
1963 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
1964 if (src->ssl_ctx.methods.max)
1965 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
1966
William Lallemand71048532021-10-20 13:28:41 +02001967#ifdef HAVE_SSL_CTX_SET_CIPHERSUITES
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001968 if (src->ssl_ctx.ciphersuites != NULL)
1969 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
William Lallemand71048532021-10-20 13:28:41 +02001970#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001971 if (src->sni_expr != NULL)
1972 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001973
William Lallemand71048532021-10-20 13:28:41 +02001974#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Olivier Houchardc7566002018-11-20 23:33:50 +01001975 if (src->ssl_ctx.alpn_str) {
1976 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1977 if (srv->ssl_ctx.alpn_str) {
1978 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1979 src->ssl_ctx.alpn_len);
1980 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1981 }
1982 }
William Lallemand71048532021-10-20 13:28:41 +02001983#endif
1984#ifdef OPENSSL_NPN_NEGOTIATED
Olivier Houchardc7566002018-11-20 23:33:50 +01001985 if (src->ssl_ctx.npn_str) {
1986 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1987 if (srv->ssl_ctx.npn_str) {
1988 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1989 src->ssl_ctx.npn_len);
1990 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1991 }
1992 }
William Lallemand71048532021-10-20 13:28:41 +02001993#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001994}
1995#endif
1996
1997/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001998 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001999 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002000 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002001 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002002int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002003{
Christopher Faulet67957bd2017-09-27 11:00:59 +02002004 char *hostname_dn;
2005 int hostname_len, hostname_dn_len;
2006
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002007 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002008 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002009
Christopher Faulet67957bd2017-09-27 11:00:59 +02002010 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002011 hostname_dn = trash.area;
Willy Tarreauc1c765f2021-10-14 07:49:49 +02002012 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len,
Emeric Brund30e9a12020-12-23 18:49:16 +01002013 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02002014 if (hostname_dn_len == -1)
2015 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02002016
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002017
Christopher Faulet67957bd2017-09-27 11:00:59 +02002018 free(srv->hostname);
2019 free(srv->hostname_dn);
2020 srv->hostname = strdup(hostname);
2021 srv->hostname_dn = strdup(hostname_dn);
2022 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002023 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002024 goto err;
2025
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002026 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002027
2028 err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002029 ha_free(&srv->hostname);
2030 ha_free(&srv->hostname_dn);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002031 return -1;
2032}
2033
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002034/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002035 * Copy <src> server settings to <srv> server allocating
2036 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002037 * This function is not supposed to be called at any time, but only
2038 * during server settings parsing or during server allocations from
2039 * a server template, and just after having calloc()'ed a new server.
2040 * So, <src> may only be a default server (when parsing server settings)
2041 * or a server template (during server allocations from a server template).
2042 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
2043 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002044 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002045static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002046{
2047 /* Connection source settings copy */
2048 srv_conn_src_cpy(srv, src);
2049
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002050 if (srv_tmpl) {
2051 srv->addr = src->addr;
2052 srv->svc_port = src->svc_port;
2053 }
2054
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002055 srv->pp_opts = src->pp_opts;
2056 if (src->rdr_pfx != NULL) {
2057 srv->rdr_pfx = strdup(src->rdr_pfx);
2058 srv->rdr_len = src->rdr_len;
2059 }
2060 if (src->cookie != NULL) {
2061 srv->cookie = strdup(src->cookie);
2062 srv->cklen = src->cklen;
2063 }
2064 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01002065 srv->check.addr = src->check.addr;
2066 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002067 srv->check.use_ssl = src->check.use_ssl;
2068 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01002069 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01002070 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05002071 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002072 /* Note: 'flags' field has potentially been already initialized. */
2073 srv->flags |= src->flags;
2074 srv->do_check = src->do_check;
2075 srv->do_agent = src->do_agent;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002076 srv->check.inter = src->check.inter;
2077 srv->check.fastinter = src->check.fastinter;
2078 srv->check.downinter = src->check.downinter;
2079 srv->agent.use_ssl = src->agent.use_ssl;
2080 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002081
2082 if (src->agent.tcpcheck_rules) {
2083 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
2084 if (srv->agent.tcpcheck_rules) {
2085 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
2086 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
2087 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
2088 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
2089 &src->agent.tcpcheck_rules->preset_vars);
2090 }
2091 }
2092
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002093 srv->agent.inter = src->agent.inter;
2094 srv->agent.fastinter = src->agent.fastinter;
2095 srv->agent.downinter = src->agent.downinter;
2096 srv->maxqueue = src->maxqueue;
2097 srv->minconn = src->minconn;
2098 srv->maxconn = src->maxconn;
2099 srv->slowstart = src->slowstart;
2100 srv->observe = src->observe;
2101 srv->onerror = src->onerror;
2102 srv->onmarkeddown = src->onmarkeddown;
2103 srv->onmarkedup = src->onmarkedup;
2104 if (src->trackit != NULL)
2105 srv->trackit = strdup(src->trackit);
2106 srv->consecutive_errors_limit = src->consecutive_errors_limit;
2107 srv->uweight = srv->iweight = src->iweight;
2108
2109 srv->check.send_proxy = src->check.send_proxy;
2110 /* health: up, but will fall down at first failure */
2111 srv->check.rise = srv->check.health = src->check.rise;
2112 srv->check.fall = src->check.fall;
2113
2114 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02002115 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
2116 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
2117 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002118 srv->check.state |= CHK_ST_PAUSED;
2119 srv->check.health = 0;
2120 }
2121
2122 /* health: up but will fall down at first failure */
2123 srv->agent.rise = srv->agent.health = src->agent.rise;
2124 srv->agent.fall = src->agent.fall;
2125
2126 if (src->resolvers_id != NULL)
2127 srv->resolvers_id = strdup(src->resolvers_id);
Emeric Brun21fbeed2020-12-23 18:01:04 +01002128 srv->resolv_opts.family_prio = src->resolv_opts.family_prio;
2129 srv->resolv_opts.accept_duplicate_ip = src->resolv_opts.accept_duplicate_ip;
2130 srv->resolv_opts.ignore_weight = src->resolv_opts.ignore_weight;
2131 if (srv->resolv_opts.family_prio == AF_UNSPEC)
2132 srv->resolv_opts.family_prio = AF_INET6;
2133 memcpy(srv->resolv_opts.pref_net,
2134 src->resolv_opts.pref_net,
2135 sizeof srv->resolv_opts.pref_net);
2136 srv->resolv_opts.pref_net_nb = src->resolv_opts.pref_net_nb;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002137
2138 srv->init_addr_methods = src->init_addr_methods;
2139 srv->init_addr = src->init_addr;
2140#if defined(USE_OPENSSL)
2141 srv_ssl_settings_cpy(srv, src);
2142#endif
2143#ifdef TCP_USER_TIMEOUT
2144 srv->tcp_ut = src->tcp_ut;
2145#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02002146 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01002147 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02002148 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01002149 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01002150 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02002151
Olivier Houchard8da5f982017-08-04 18:35:36 +02002152 if (srv_tmpl)
2153 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08002154
2155 srv->check.via_socks4 = src->check.via_socks4;
2156 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002157}
2158
Willy Tarreau198e92a2021-03-05 10:23:32 +01002159/* allocate a server and attach it to the global servers_list. Returns
2160 * the server on success, otherwise NULL.
2161 */
William Lallemand313bfd12018-10-26 14:47:32 +02002162struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002163{
2164 struct server *srv;
2165
2166 srv = calloc(1, sizeof *srv);
2167 if (!srv)
2168 return NULL;
2169
2170 srv->obj_type = OBJ_TYPE_SERVER;
2171 srv->proxy = proxy;
Patrick Hemmer0355dab2018-05-11 12:52:31 -04002172 srv->pendconns = EB_ROOT;
Willy Tarreau2b718102021-04-21 07:32:39 +02002173 LIST_APPEND(&servers_list, &srv->global_list);
Emeric Brun0c4a8a32021-06-11 10:48:45 +02002174 LIST_INIT(&srv->srv_rec_item);
Emeric Brunf9ca5d82021-06-11 10:08:05 +02002175 LIST_INIT(&srv->ip_rec_item);
Christopher Faulet40a007c2017-07-03 15:41:01 +02002176
Emeric Brun52a91d32017-08-31 14:41:55 +02002177 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002178 srv->last_change = now.tv_sec;
2179
Christopher Faulet38290462020-04-21 11:46:40 +02002180 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002181 srv->check.status = HCHK_STATUS_INI;
2182 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01002183 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02002184 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002185
Christopher Faulet38290462020-04-21 11:46:40 +02002186 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002187 srv->agent.status = HCHK_STATUS_INI;
2188 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01002189 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002190 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
Frédéric Lécaillef46c10c2020-11-23 14:29:28 +01002191#if defined(USE_QUIC)
2192 srv->cids = EB_ROOT_UNIQUE;
2193#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002194
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01002195 srv->extra_counters = NULL;
William Lallemand3ce6eed2021-02-08 10:43:44 +01002196#ifdef USE_OPENSSL
2197 HA_RWLOCK_INIT(&srv->ssl_ctx.lock);
2198#endif
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01002199
Willy Tarreau975b1552019-06-06 16:25:55 +02002200 /* please don't put default server settings here, they are set in
Willy Tarreau144289b2021-02-12 08:19:01 +01002201 * proxy_preset_defaults().
Willy Tarreau975b1552019-06-06 16:25:55 +02002202 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002203 return srv;
2204}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002205
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02002206/* Increment the dynamic server refcount. */
Amaury Denoyelle4a699422021-08-25 14:39:53 +02002207void srv_use_dynsrv(struct server *srv)
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02002208{
2209 BUG_ON(!(srv->flags & SRV_F_DYNAMIC));
2210 HA_ATOMIC_INC(&srv->refcount_dynsrv);
2211}
2212
2213/* Decrement the dynamic server refcount. */
2214static uint srv_release_dynsrv(struct server *srv)
2215{
2216 BUG_ON(!(srv->flags & SRV_F_DYNAMIC));
2217 return HA_ATOMIC_SUB_FETCH(&srv->refcount_dynsrv, 1);
2218}
2219
Amaury Denoyelleff836742021-08-09 15:08:54 +02002220/* Deallocate a server <srv> and its member. <srv> must be allocated. For
2221 * dynamic servers, its refcount is decremented first. The free operations are
2222 * conducted only if the refcount is nul, unless the process is stopping.
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002223 *
2224 * As a convenience, <srv.next> is returned if srv is not NULL. It may be useful
2225 * when calling free_server on the list of servers.
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002226 */
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002227struct server *free_server(struct server *srv)
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002228{
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002229 struct server *next = NULL;
2230
2231 next = srv->next;
2232
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02002233 /* For dynamic servers, decrement the reference counter. Only free the
2234 * server when reaching zero.
2235 */
Amaury Denoyelleff836742021-08-09 15:08:54 +02002236 if (likely(!(global.mode & MODE_STOPPING))) {
2237 if (srv->flags & SRV_F_DYNAMIC) {
2238 if (srv_release_dynsrv(srv))
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002239 goto end;
Amaury Denoyelleff836742021-08-09 15:08:54 +02002240 }
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02002241 }
2242
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002243 task_destroy(srv->warmup);
Christopher Faulet2c0f5272021-06-15 16:17:17 +02002244 task_destroy(srv->srvrq_check);
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002245
2246 free(srv->id);
2247 free(srv->cookie);
2248 free(srv->hostname);
2249 free(srv->hostname_dn);
2250 free((char*)srv->conf.file);
2251 free(srv->per_thr);
2252 free(srv->curr_idle_thr);
2253 free(srv->resolvers_id);
2254 free(srv->addr_node.key);
Amaury Denoyellefb247942021-04-20 16:48:22 +02002255 free(srv->lb_nodes);
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002256
2257 if (srv->use_ssl == 1 || srv->check.use_ssl == 1 || (srv->proxy->options & PR_O_TCPCHK_SSL)) {
2258 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->destroy_srv)
2259 xprt_get(XPRT_SSL)->destroy_srv(srv);
2260 }
2261 HA_SPIN_DESTROY(&srv->lock);
2262
Willy Tarreau2b718102021-04-21 07:32:39 +02002263 LIST_DELETE(&srv->global_list);
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002264
2265 EXTRA_COUNTERS_FREE(srv->extra_counters);
2266
2267 free(srv);
2268 srv = NULL;
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002269
2270 end:
2271 return next;
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002272}
2273
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002274/*
2275 * Parse as much as possible such a range string argument: low[-high]
2276 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
2277 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
2278 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
2279 * Returns 0 if succeeded, -1 if not.
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002280 */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002281static int _srv_parse_tmpl_range(struct server *srv, const char *arg,
2282 int *nb_low, int *nb_high)
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002283{
2284 char *nb_high_arg;
2285
2286 *nb_high = 0;
2287 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002288 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002289
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002290 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002291 *nb_high_arg++ = '\0';
2292 *nb_high = atoi(nb_high_arg);
2293 }
2294 else {
2295 *nb_high += *nb_low;
2296 *nb_low = 1;
2297 }
2298
2299 if (*nb_low < 0 || *nb_high < *nb_low)
2300 return -1;
2301
2302 return 0;
2303}
2304
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002305/* Parse as much as possible such a range string argument: low[-high]
2306 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
2307 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
2308 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002309 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002310 * initialize a new server on startup.
2311 *
2312 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
2313 * Returns 0 if succeeded, -1 if not.
2314 */
2315static inline void _srv_parse_set_id_from_prefix(struct server *srv,
2316 const char *prefix, int nb)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002317{
2318 chunk_printf(&trash, "%s%d", prefix, nb);
2319 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002320 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002321}
2322
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002323/* Initialize as much as possible servers from <srv> server template.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002324 * Note that a server template is a special server with
2325 * a few different parameters than a server which has
2326 * been parsed mostly the same way as a server.
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002327 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002328 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002329 * initialize a new server on startup.
2330 *
Joseph Herlant44466822018-11-15 08:57:51 -08002331 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002332 * 'srv' template included.
2333 */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002334static int _srv_parse_tmpl_init(struct server *srv, struct proxy *px)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002335{
2336 int i;
2337 struct server *newsrv;
2338
2339 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 +02002340 newsrv = new_server(px);
2341 if (!newsrv)
2342 goto err;
2343
Christopher Faulet75bef002020-11-02 22:04:55 +01002344 newsrv->conf.file = strdup(srv->conf.file);
2345 newsrv->conf.line = srv->conf.line;
2346
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002347 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002348 srv_prepare_for_resolution(newsrv, srv->hostname);
William Lallemand71048532021-10-20 13:28:41 +02002349#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002350 if (newsrv->sni_expr) {
2351 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
2352 if (!newsrv->ssl_ctx.sni)
2353 goto err;
2354 }
William Lallemand71048532021-10-20 13:28:41 +02002355#endif
Emeric Brun0c4a8a32021-06-11 10:48:45 +02002356 /* append to list of servers available to receive an hostname */
Emeric Brun3ecaf532021-06-14 10:02:18 +02002357 if (newsrv->srvrq)
2358 LIST_APPEND(&newsrv->srvrq->attached_servers, &newsrv->srv_rec_item);
Emeric Brun0c4a8a32021-06-11 10:48:45 +02002359
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002360 /* Set this new server ID. */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002361 _srv_parse_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002362
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002363 /* Linked backwards first. This will be restablished after parsing. */
2364 newsrv->next = px->srv;
2365 px->srv = newsrv;
2366 }
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002367 _srv_parse_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002368
2369 return i - srv->tmpl_info.nb_low;
2370
2371 err:
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002372 _srv_parse_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002373 if (newsrv) {
William Lallemand71048532021-10-20 13:28:41 +02002374#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002375 release_sample_expr(newsrv->ssl_ctx.sni);
William Lallemand71048532021-10-20 13:28:41 +02002376#endif
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002377 free_check(&newsrv->agent);
2378 free_check(&newsrv->check);
Willy Tarreau2b718102021-04-21 07:32:39 +02002379 LIST_DELETE(&newsrv->global_list);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002380 }
2381 free(newsrv);
2382 return i - srv->tmpl_info.nb_low;
2383}
2384
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002385/* Allocate a new server pointed by <srv> and try to parse the first arguments
2386 * in <args> as an address for a server or an address-range for a template or
2387 * nothing for a default-server. <cur_arg> is incremented to the next argument.
2388 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002389 * This function is first intended to be used through parse_server to
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002390 * initialize a new server on startup.
2391 *
2392 * A mask of errors is returned. On a parsing error, ERR_FATAL is set. In case
2393 * of memory exhaustion, ERR_ABORT is set. If the server cannot be allocated,
2394 * <srv> will be set to NULL.
2395 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002396static int _srv_parse_init(struct server **srv, char **args, int *cur_arg,
2397 struct proxy *curproxy,
2398 int parse_flags, char **errmsg)
Willy Tarreau272adea2014-03-31 10:39:59 +02002399{
2400 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002401 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02002402 int err_code = 0;
Willy Tarreau07101d52015-09-08 16:16:35 +02002403 char *fqdn = NULL;
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002404 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002405
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002406 *srv = NULL;
2407
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002408 /* There is no mandatory first arguments for default server. */
2409 if (parse_flags & SRV_PARSE_PARSE_ADDR) {
2410 if (parse_flags & SRV_PARSE_TEMPLATE) {
2411 if (!*args[3]) {
2412 /* 'server-template' line number of argument check. */
2413 memprintf(errmsg, "'%s' expects <prefix> <nb | range> <addr>[:<port>] as arguments.",
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002414 args[0]);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002415 err_code |= ERR_ALERT | ERR_FATAL;
2416 goto out;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002417 }
2418
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002419 err = invalid_prefix_char(args[1]);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002420 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002421 else {
2422 if (!*args[2]) {
2423 /* 'server' line number of argument check. */
2424 memprintf(errmsg, "'%s' expects <name> and <addr>[:<port>] as arguments.",
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002425 args[0]);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002426 err_code |= ERR_ALERT | ERR_FATAL;
2427 goto out;
2428 }
2429
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002430 err = invalid_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002431 }
2432
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002433 if (err) {
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002434 memprintf(errmsg, "character '%c' is not permitted in %s %s '%s'.",
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002435 *err, args[0], !(parse_flags & SRV_PARSE_TEMPLATE) ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002436 err_code |= ERR_ALERT | ERR_FATAL;
2437 goto out;
2438 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002439 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002440
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002441 *cur_arg = 2;
2442 if (parse_flags & SRV_PARSE_TEMPLATE) {
2443 /* Parse server-template <nb | range> arg. */
2444 if (_srv_parse_tmpl_range(newsrv, args[*cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
2445 memprintf(errmsg, "Wrong %s number or range arg '%s'.",
2446 args[0], args[*cur_arg]);
2447 err_code |= ERR_ALERT | ERR_FATAL;
2448 goto out;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002449 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002450 (*cur_arg)++;
2451 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002452
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002453 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
2454 struct sockaddr_storage *sk;
2455 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002456
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002457 *srv = newsrv = new_server(curproxy);
2458 if (!newsrv) {
2459 memprintf(errmsg, "out of memory.");
2460 err_code |= ERR_ALERT | ERR_ABORT;
2461 goto out;
2462 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002463
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002464 if (parse_flags & SRV_PARSE_TEMPLATE) {
2465 newsrv->tmpl_info.nb_low = tmpl_range_low;
2466 newsrv->tmpl_info.nb_high = tmpl_range_high;
2467 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002468
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002469 if (parse_flags & SRV_PARSE_DYNAMIC)
2470 newsrv->flags |= SRV_F_DYNAMIC;
2471
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002472 /* Note: for a server template, its id is its prefix.
2473 * This is a temporary id which will be used for server allocations to come
2474 * after parsing.
2475 */
2476 if (!(parse_flags & SRV_PARSE_TEMPLATE))
2477 newsrv->id = strdup(args[1]);
2478 else
2479 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002480
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002481 /* several ways to check the port component :
2482 * - IP => port=+0, relative (IPv4 only)
2483 * - IP: => port=+0, relative
2484 * - IP:N => port=N, absolute
2485 * - IP:+N => port=+N, relative
2486 * - IP:-N => port=-N, relative
2487 */
2488 if (!(parse_flags & SRV_PARSE_PARSE_ADDR))
2489 goto skip_addr;
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002490
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002491 sk = str2sa_range(args[*cur_arg], &port, &port1, &port2, NULL, NULL,
2492 errmsg, NULL, &fqdn,
2493 (parse_flags & SRV_PARSE_INITIAL_RESOLVE ? PA_O_RESOLVE : 0) | PA_O_PORT_OK | PA_O_PORT_OFS | PA_O_STREAM | PA_O_XPRT | PA_O_CONNECT);
2494 if (!sk) {
2495 memprintf(errmsg, "'%s %s' : %s", args[0], args[1], *errmsg);
2496 err_code |= ERR_ALERT | ERR_FATAL;
2497 goto out;
2498 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002499
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002500 if (!port1 || !port2) {
2501 /* no port specified, +offset, -offset */
2502 newsrv->flags |= SRV_F_MAPPORTS;
2503 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002504
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002505 /* save hostname and create associated name resolution */
2506 if (fqdn) {
2507 if (fqdn[0] == '_') { /* SRV record */
2508 /* Check if a SRV request already exists, and if not, create it */
2509 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
2510 newsrv->srvrq = new_resolv_srvrq(newsrv, fqdn);
2511 if (newsrv->srvrq == NULL) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002512 err_code |= ERR_ALERT | ERR_FATAL;
2513 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002514 }
Christopher Faulet08736f92021-06-29 20:52:35 +02002515 LIST_APPEND(&newsrv->srvrq->attached_servers, &newsrv->srv_rec_item);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002516 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002517 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
2518 memprintf(errmsg, "Can't create DNS resolution for server '%s'",
2519 newsrv->id);
Willy Tarreau272adea2014-03-31 10:39:59 +02002520 err_code |= ERR_ALERT | ERR_FATAL;
2521 goto out;
2522 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002523 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002524
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002525 newsrv->addr = *sk;
2526 newsrv->svc_port = port;
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02002527 /*
2528 * we don't need to lock the server here, because
2529 * we are in the process of initializing.
2530 *
2531 * Note that the server is not attached into the proxy tree if
2532 * this is a dynamic server.
2533 */
2534 srv_set_addr_desc(newsrv, !(parse_flags & SRV_PARSE_DYNAMIC));
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002535
2536 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
2537 memprintf(errmsg, "Unknown protocol family %d '%s'",
2538 newsrv->addr.ss_family, args[*cur_arg]);
2539 err_code |= ERR_ALERT | ERR_FATAL;
2540 goto out;
Willy Tarreau272adea2014-03-31 10:39:59 +02002541 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002542
2543 (*cur_arg)++;
2544 skip_addr:
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002545 if (!(parse_flags & SRV_PARSE_DYNAMIC)) {
2546 /* Copy default server settings to new server */
2547 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
2548 } else {
2549 /* Initialize dynamic server weight to 1 */
2550 newsrv->uweight = newsrv->iweight = 1;
2551
2552 /* A dynamic server is disabled on startup */
2553 newsrv->next_admin = SRV_ADMF_FMAINT;
2554 newsrv->next_state = SRV_ST_STOPPED;
2555 server_recalc_eweight(newsrv, 0);
2556 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002557 HA_SPIN_INIT(&newsrv->lock);
2558 }
2559 else {
2560 *srv = newsrv = &curproxy->defsrv;
2561 *cur_arg = 1;
2562 newsrv->resolv_opts.family_prio = AF_INET6;
2563 newsrv->resolv_opts.accept_duplicate_ip = 0;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002564 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002565
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002566 free(fqdn);
2567 return 0;
Willy Tarreau9faebe32019-06-07 19:00:37 +02002568
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002569out:
2570 free(fqdn);
2571 return err_code;
2572}
Willy Tarreau272adea2014-03-31 10:39:59 +02002573
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002574/* Parse the server keyword in <args>.
2575 * <cur_arg> is incremented beyond the keyword optional value. Note that this
2576 * might not be the case if an error is reported.
2577 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002578 * This function is first intended to be used through parse_server to
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002579 * initialize a new server on startup.
2580 *
2581 * A mask of errors is returned. ERR_FATAL is set if the parsing should be
2582 * interrupted.
2583 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002584static int _srv_parse_kw(struct server *srv, char **args, int *cur_arg,
2585 struct proxy *curproxy,
2586 int parse_flags, char **errmsg)
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002587{
2588 int err_code = 0;
2589 struct srv_kw *kw;
2590 const char *best;
Willy Tarreau272adea2014-03-31 10:39:59 +02002591
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002592 kw = srv_find_kw(args[*cur_arg]);
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002593 if (!kw) {
2594 best = srv_find_best_kw(args[*cur_arg]);
2595 if (best)
2596 memprintf(errmsg, "unknown keyword '%s'; did you mean '%s' maybe ?",
2597 args[*cur_arg], best);
2598 else
2599 memprintf(errmsg, "unknown keyword '%s'.",
2600 args[*cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002601
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002602 return ERR_ALERT | ERR_FATAL;
2603 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002604
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002605 if (!kw->parse) {
2606 memprintf(errmsg, "'%s' option is not implemented in this version (check build options)",
2607 args[*cur_arg]);
2608 err_code = ERR_ALERT | ERR_FATAL;
2609 goto out;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002610 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002611
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002612 if ((parse_flags & SRV_PARSE_DEFAULT_SERVER) && !kw->default_ok) {
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002613 memprintf(errmsg, "'%s' option is not accepted in default-server sections",
2614 args[*cur_arg]);
2615 err_code = ERR_ALERT;
2616 goto out;
2617 }
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002618 else if ((parse_flags & SRV_PARSE_DYNAMIC) && !kw->dynamic_ok) {
2619 memprintf(errmsg, "'%s' option is not accepted for dynamic server",
2620 args[*cur_arg]);
2621 err_code |= ERR_ALERT;
2622 goto out;
2623 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002624
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002625 err_code = kw->parse(args, cur_arg, curproxy, srv, errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002626
2627out:
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002628 if (kw->skip != -1)
2629 *cur_arg += 1 + kw->skip;
2630
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002631 return err_code;
2632}
2633
William Lallemand71048532021-10-20 13:28:41 +02002634#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002635/* This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002636 * initialize a new server on startup.
2637 */
2638static int _srv_parse_sni_expr_init(char **args, int cur_arg,
2639 struct server *srv, struct proxy *proxy,
2640 char **errmsg)
2641{
2642 int ret;
2643
2644 if (!srv->sni_expr)
2645 return 0;
2646
2647 ret = server_parse_sni_expr(srv, proxy, errmsg);
2648 if (!ret)
2649 return 0;
2650
2651 return ret;
2652}
William Lallemand71048532021-10-20 13:28:41 +02002653#endif
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002654
2655/* Server initializations finalization.
2656 * Initialize health check, agent check and SNI expression if enabled.
2657 * Must not be called for a default server instance.
2658 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002659 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002660 * initialize a new server on startup.
2661 */
2662static int _srv_parse_finalize(char **args, int cur_arg,
2663 struct server *srv, struct proxy *px,
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002664 int parse_flags, char **errmsg)
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002665{
William Lallemand71048532021-10-20 13:28:41 +02002666#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002667 int ret;
William Lallemand71048532021-10-20 13:28:41 +02002668#endif
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002669
2670 if (srv->do_check && srv->trackit) {
2671 memprintf(errmsg, "unable to enable checks and tracking at the same time!");
2672 return ERR_ALERT | ERR_FATAL;
2673 }
2674
2675 if (srv->do_agent && !srv->agent.port) {
2676 memprintf(errmsg, "server %s does not have agent port. Agent check has been disabled.",
2677 srv->id);
2678 return ERR_ALERT | ERR_FATAL;
2679 }
2680
William Lallemand71048532021-10-20 13:28:41 +02002681#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002682 if ((ret = _srv_parse_sni_expr_init(args, cur_arg, srv, px, errmsg)) != 0)
2683 return ret;
William Lallemand71048532021-10-20 13:28:41 +02002684#endif
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002685
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002686 /* A dynamic server is disabled on startup. It must not be counted as
2687 * an active backend entry.
2688 */
2689 if (!(parse_flags & SRV_PARSE_DYNAMIC)) {
2690 if (srv->flags & SRV_F_BACKUP)
2691 px->srv_bck++;
2692 else
2693 px->srv_act++;
2694 }
2695
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002696 srv_lb_commit_status(srv);
2697
2698 return 0;
2699}
2700
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002701int parse_server(const char *file, int linenum, char **args,
2702 struct proxy *curproxy, const struct proxy *defproxy,
2703 int parse_flags)
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002704{
2705 struct server *newsrv = NULL;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002706 char *errmsg = NULL;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002707 int err_code = 0;
2708
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002709 int cur_arg;
Willy Tarreau272adea2014-03-31 10:39:59 +02002710
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002711 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER) && curproxy == defproxy) {
2712 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
2713 err_code |= ERR_ALERT | ERR_FATAL;
2714 goto out;
2715 }
2716 else if (failifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL)) {
2717 err_code |= ERR_ALERT | ERR_FATAL;
2718 goto out;
2719 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002720
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002721 if ((parse_flags & (SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_PARSE_ADDR)) ==
2722 (SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_PARSE_ADDR)) {
2723 if (!*args[2])
2724 return 0;
2725 }
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002726
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002727 err_code = _srv_parse_init(&newsrv, args, &cur_arg, curproxy,
2728 parse_flags, &errmsg);
2729 if (errmsg) {
2730 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
2731 free(errmsg);
2732 }
Amaury Denoyellecf58dd72021-03-08 16:35:54 +01002733
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002734 /* the servers are linked backwards first */
2735 if (newsrv && !(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
2736 newsrv->next = curproxy->srv;
2737 curproxy->srv = newsrv;
2738 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002739
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002740 if (err_code & ERR_CODE)
2741 goto out;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002742
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002743 newsrv->conf.file = strdup(file);
2744 newsrv->conf.line = linenum;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002745
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002746 while (*args[cur_arg]) {
2747 errmsg = NULL;
2748 err_code = _srv_parse_kw(newsrv, args, &cur_arg, curproxy,
2749 parse_flags, &errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002750
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002751 if (err_code & ERR_ALERT) {
2752 display_parser_err(file, linenum, args, cur_arg, err_code, &errmsg);
2753 free(errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002754 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002755
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002756 if (err_code & ERR_FATAL)
2757 goto out;
2758 }
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002759
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002760 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002761 err_code |= _srv_parse_finalize(args, cur_arg, newsrv, curproxy, parse_flags, &errmsg);
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002762 if (err_code) {
2763 display_parser_err(file, linenum, args, cur_arg, err_code, &errmsg);
2764 free(errmsg);
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002765 }
2766
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002767 if (err_code & ERR_FATAL)
2768 goto out;
Willy Tarreau272adea2014-03-31 10:39:59 +02002769 }
Amaury Denoyellecf58dd72021-03-08 16:35:54 +01002770
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002771 if (parse_flags & SRV_PARSE_TEMPLATE)
2772 _srv_parse_tmpl_init(newsrv, curproxy);
2773
Amaury Denoyellef88af882021-06-08 17:00:20 +02002774 /* If the server id is fixed, insert it in the proxy used_id tree.
2775 * This is needed to detect a later duplicate id via srv_parse_id.
2776 *
2777 * If no is specified, a dynamic one is generated in
2778 * check_config_validity.
2779 */
2780 if (newsrv->flags & SRV_F_FORCED_ID)
2781 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
2782
Amaury Denoyelle24abb0c2021-05-07 15:13:51 +02002783 HA_DIAG_WARNING_COND((curproxy->cap & PR_CAP_LB) && !newsrv->uweight,
Amaury Denoyelleda0e7f62021-03-30 10:26:27 +02002784 "parsing [%s:%d] : 'server %s' : configured with weight of 0 will never be selected by load balancing algorithms\n",
2785 file, linenum, newsrv->id);
2786
Willy Tarreau272adea2014-03-31 10:39:59 +02002787 return 0;
2788
2789 out:
Willy Tarreau272adea2014-03-31 10:39:59 +02002790 return err_code;
2791}
2792
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002793/* Returns a pointer to the first server matching either id <id>.
2794 * NULL is returned if no match is found.
2795 * the lookup is performed in the backend <bk>
2796 */
2797struct server *server_find_by_id(struct proxy *bk, int id)
2798{
2799 struct eb32_node *eb32;
2800 struct server *curserver;
2801
2802 if (!bk || (id ==0))
2803 return NULL;
2804
2805 /* <bk> has no backend capabilities, so it can't have a server */
2806 if (!(bk->cap & PR_CAP_BE))
2807 return NULL;
2808
2809 curserver = NULL;
2810
2811 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2812 if (eb32)
2813 curserver = container_of(eb32, struct server, conf.id);
2814
2815 return curserver;
2816}
2817
2818/* Returns a pointer to the first server matching either name <name>, or id
2819 * if <name> starts with a '#'. NULL is returned if no match is found.
2820 * the lookup is performed in the backend <bk>
2821 */
2822struct server *server_find_by_name(struct proxy *bk, const char *name)
2823{
2824 struct server *curserver;
2825
2826 if (!bk || !name)
2827 return NULL;
2828
2829 /* <bk> has no backend capabilities, so it can't have a server */
2830 if (!(bk->cap & PR_CAP_BE))
2831 return NULL;
2832
2833 curserver = NULL;
2834 if (*name == '#') {
2835 curserver = server_find_by_id(bk, atoi(name + 1));
2836 if (curserver)
2837 return curserver;
2838 }
2839 else {
2840 curserver = bk->srv;
2841
2842 while (curserver && (strcmp(curserver->id, name) != 0))
2843 curserver = curserver->next;
2844
2845 if (curserver)
2846 return curserver;
2847 }
2848
2849 return NULL;
2850}
2851
2852struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2853{
2854 struct server *byname;
2855 struct server *byid;
2856
2857 if (!name && !id)
2858 return NULL;
2859
2860 if (diff)
2861 *diff = 0;
2862
2863 byname = byid = NULL;
2864
2865 if (name) {
2866 byname = server_find_by_name(bk, name);
2867 if (byname && (!id || byname->puid == id))
2868 return byname;
2869 }
2870
2871 /* remaining possibilities :
2872 * - name not set
2873 * - name set but not found
2874 * - name found but ID doesn't match
2875 */
2876 if (id) {
2877 byid = server_find_by_id(bk, id);
2878 if (byid) {
2879 if (byname) {
2880 /* use id only if forced by configuration */
2881 if (byid->flags & SRV_F_FORCED_ID) {
2882 if (diff)
2883 *diff |= 2;
2884 return byid;
2885 }
2886 else {
2887 if (diff)
2888 *diff |= 1;
2889 return byname;
2890 }
2891 }
2892
2893 /* remaining possibilities:
2894 * - name not set
2895 * - name set but not found
2896 */
2897 if (name && diff)
2898 *diff |= 2;
2899 return byid;
2900 }
2901
2902 /* id bot found */
2903 if (byname) {
2904 if (diff)
2905 *diff |= 1;
2906 return byname;
2907 }
2908 }
2909
2910 return NULL;
2911}
2912
Simon Horman7d09b9a2013-02-12 10:45:51 +09002913/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02002914 * update a server's current IP address.
2915 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
2916 * ip is in network format.
2917 * updater is a string which contains an information about the requester of the update.
2918 * updater is used if not NULL.
2919 *
2920 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02002921 *
2922 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02002923 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002924int srv_update_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02002925{
Christopher Fauletd6c6b5f2020-09-08 10:27:24 +02002926 /* save the new IP family & address if necessary */
2927 switch (ip_sin_family) {
2928 case AF_INET:
2929 if (s->addr.ss_family == ip_sin_family &&
2930 !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
2931 return 0;
2932 break;
2933 case AF_INET6:
2934 if (s->addr.ss_family == ip_sin_family &&
2935 !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
2936 return 0;
2937 break;
2938 };
2939
Baptiste Assmann14e40142015-04-14 01:13:07 +02002940 /* generates a log line and a warning on stderr */
2941 if (1) {
2942 /* book enough space for both IPv4 and IPv6 */
2943 char oldip[INET6_ADDRSTRLEN];
2944 char newip[INET6_ADDRSTRLEN];
2945
2946 memset(oldip, '\0', INET6_ADDRSTRLEN);
2947 memset(newip, '\0', INET6_ADDRSTRLEN);
2948
2949 /* copy old IP address in a string */
2950 switch (s->addr.ss_family) {
2951 case AF_INET:
2952 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
2953 break;
2954 case AF_INET6:
2955 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
2956 break;
Christopher Fauletb0b76072020-09-08 10:38:40 +02002957 default:
2958 strcpy(oldip, "(none)");
2959 break;
Baptiste Assmann14e40142015-04-14 01:13:07 +02002960 };
2961
2962 /* copy new IP address in a string */
2963 switch (ip_sin_family) {
2964 case AF_INET:
2965 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
2966 break;
2967 case AF_INET6:
2968 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
2969 break;
2970 };
2971
2972 /* save log line into a buffer */
2973 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
2974 s->proxy->id, s->id, oldip, newip, updater);
2975
2976 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002977 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002978
2979 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002980 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002981 }
2982
2983 /* save the new IP family */
2984 s->addr.ss_family = ip_sin_family;
2985 /* save the new IP address */
2986 switch (ip_sin_family) {
2987 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02002988 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002989 break;
2990 case AF_INET6:
2991 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
2992 break;
2993 };
Olivier Houchard4e694042017-03-14 20:01:29 +01002994 srv_set_dyncookie(s);
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02002995 srv_set_addr_desc(s, 1);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002996
2997 return 0;
2998}
2999
William Dauchy7cabc062021-02-11 22:51:24 +01003000/* update agent health check address and port
3001 * addr can be ip4/ip6 or a hostname
3002 * if one error occurs, don't apply anything
3003 * must be called with the server lock held.
3004 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003005const char *srv_update_agent_addr_port(struct server *s, const char *addr, const char *port)
William Dauchy7cabc062021-02-11 22:51:24 +01003006{
3007 struct sockaddr_storage sk;
3008 struct buffer *msg;
3009 int new_port;
3010
3011 msg = get_trash_chunk();
3012 chunk_reset(msg);
3013
3014 if (!(s->agent.state & CHK_ST_ENABLED)) {
3015 chunk_strcat(msg, "agent checks are not enabled on this server");
3016 goto out;
3017 }
3018 if (addr) {
3019 memset(&sk, 0, sizeof(struct sockaddr_storage));
3020 if (str2ip(addr, &sk) == NULL) {
3021 chunk_appendf(msg, "invalid addr '%s'", addr);
3022 goto out;
3023 }
3024 }
3025 if (port) {
3026 if (strl2irc(port, strlen(port), &new_port) != 0) {
3027 chunk_appendf(msg, "provided port is not an integer");
3028 goto out;
3029 }
3030 if (new_port < 0 || new_port > 65535) {
3031 chunk_appendf(msg, "provided port is invalid");
3032 goto out;
3033 }
3034 }
3035out:
3036 if (msg->data)
3037 return msg->area;
3038 else {
3039 if (addr)
3040 set_srv_agent_addr(s, &sk);
3041 if (port)
3042 set_srv_agent_port(s, new_port);
3043 }
3044 return NULL;
3045}
3046
William Dauchyb456e1f2021-02-11 22:51:23 +01003047/* update server health check address and port
3048 * addr must be ip4 or ip6, it won't be resolved
3049 * if one error occurs, don't apply anything
3050 * must be called with the server lock held.
3051 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003052const char *srv_update_check_addr_port(struct server *s, const char *addr, const char *port)
William Dauchyb456e1f2021-02-11 22:51:23 +01003053{
3054 struct sockaddr_storage sk;
3055 struct buffer *msg;
3056 int new_port;
3057
3058 msg = get_trash_chunk();
3059 chunk_reset(msg);
3060
3061 if (!(s->check.state & CHK_ST_ENABLED)) {
3062 chunk_strcat(msg, "health checks are not enabled on this server");
3063 goto out;
3064 }
3065 if (addr) {
3066 memset(&sk, 0, sizeof(struct sockaddr_storage));
3067 if (str2ip2(addr, &sk, 0) == NULL) {
3068 chunk_appendf(msg, "invalid addr '%s'", addr);
3069 goto out;
3070 }
3071 }
3072 if (port) {
3073 if (strl2irc(port, strlen(port), &new_port) != 0) {
3074 chunk_appendf(msg, "provided port is not an integer");
3075 goto out;
3076 }
3077 if (new_port < 0 || new_port > 65535) {
3078 chunk_appendf(msg, "provided port is invalid");
3079 goto out;
3080 }
3081 /* prevent the update of port to 0 if MAPPORTS are in use */
3082 if ((s->flags & SRV_F_MAPPORTS) && new_port == 0) {
3083 chunk_appendf(msg, "can't unset 'port' since MAPPORTS is in use");
3084 goto out;
3085 }
3086 }
3087out:
3088 if (msg->data)
3089 return msg->area;
3090 else {
3091 if (addr)
3092 s->check.addr = sk;
3093 if (port)
3094 s->check.port = new_port;
3095 }
3096 return NULL;
3097}
3098
Baptiste Assmann14e40142015-04-14 01:13:07 +02003099/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003100 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3101 *
3102 * Caller can pass its name through <updater> to get it integrated in the response message
3103 * returned by the function.
3104 *
3105 * The function first does the following, in that order:
3106 * - validates the new addr and/or port
3107 * - checks if an update is required (new IP or port is different than current ones)
3108 * - checks the update is allowed:
3109 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3110 * - allow all changes if no CHECKS are configured
3111 * - if CHECK is configured:
3112 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3113 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3114 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02003115 *
3116 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003117 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003118const char *srv_update_addr_port(struct server *s, const char *addr, const char *port, char *updater)
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003119{
3120 struct sockaddr_storage sa;
3121 int ret, port_change_required;
3122 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003123 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02003124 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003125 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003126
3127 msg = get_trash_chunk();
3128 chunk_reset(msg);
3129
3130 if (addr) {
3131 memset(&sa, 0, sizeof(struct sockaddr_storage));
3132 if (str2ip2(addr, &sa, 0) == NULL) {
3133 chunk_printf(msg, "Invalid addr '%s'", addr);
3134 goto out;
3135 }
3136
3137 /* changes are allowed on AF_INET* families only */
3138 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3139 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3140 goto out;
3141 }
3142
3143 /* collecting data currently setup */
3144 memset(current_addr, '\0', sizeof(current_addr));
3145 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3146 /* changes are allowed on AF_INET* families only */
3147 if ((ret != AF_INET) && (ret != AF_INET6)) {
3148 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3149 goto out;
3150 }
3151
3152 /* applying ADDR changes if required and allowed
3153 * ipcmp returns 0 when both ADDR are the same
3154 */
3155 if (ipcmp(&s->addr, &sa) == 0) {
3156 chunk_appendf(msg, "no need to change the addr");
3157 goto port;
3158 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003159 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003160 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003161
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003162 /* update report for caller */
3163 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3164 }
3165
3166 port:
3167 if (port) {
3168 char sign = '\0';
3169 char *endptr;
3170
3171 if (addr)
3172 chunk_appendf(msg, ", ");
3173
3174 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003175 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003176
3177 /* check if PORT change is required */
3178 port_change_required = 0;
3179
3180 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003181 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003182 new_port = strtol(port, &endptr, 10);
3183 if ((errno != 0) || (port == endptr)) {
3184 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3185 goto out;
3186 }
3187
3188 /* check if caller triggers a port mapped or offset */
3189 if (sign == '-' || (sign == '+')) {
3190 /* check if server currently uses port map */
3191 if (!(s->flags & SRV_F_MAPPORTS)) {
3192 /* switch from fixed port to port map mandatorily triggers
3193 * a port change */
3194 port_change_required = 1;
3195 /* check is configured
3196 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3197 * prevent PORT change if check doesn't have it's dedicated port while switching
3198 * to port mapping */
William Dauchy69f118d2021-02-03 22:30:07 +01003199 if (!s->check.port) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003200 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.");
3201 goto out;
3202 }
3203 }
3204 /* we're already using port maps */
3205 else {
3206 port_change_required = current_port != new_port;
3207 }
3208 }
3209 /* fixed port */
3210 else {
3211 port_change_required = current_port != new_port;
3212 }
3213
3214 /* applying PORT changes if required and update response message */
3215 if (port_change_required) {
3216 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003217 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003218 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003219
3220 /* prepare message */
3221 chunk_appendf(msg, "port changed from '");
3222 if (s->flags & SRV_F_MAPPORTS)
3223 chunk_appendf(msg, "+");
3224 chunk_appendf(msg, "%d' to '", current_port);
3225
3226 if (sign == '-') {
3227 s->flags |= SRV_F_MAPPORTS;
3228 chunk_appendf(msg, "%c", sign);
3229 /* just use for result output */
3230 new_port = -new_port;
3231 }
3232 else if (sign == '+') {
3233 s->flags |= SRV_F_MAPPORTS;
3234 chunk_appendf(msg, "%c", sign);
3235 }
3236 else {
3237 s->flags &= ~SRV_F_MAPPORTS;
3238 }
3239
3240 chunk_appendf(msg, "%d'", new_port);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003241 }
3242 else {
3243 chunk_appendf(msg, "no need to change the port");
3244 }
3245 }
3246
3247out:
William Dauchy6318d332020-05-02 21:52:36 +02003248 if (changed) {
3249 /* force connection cleanup on the given server */
3250 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01003251 srv_set_dyncookie(s);
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02003252 srv_set_addr_desc(s, 1);
William Dauchy6318d332020-05-02 21:52:36 +02003253 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003254 if (updater)
3255 chunk_appendf(msg, " by '%s'", updater);
3256 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003257 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003258}
3259
Christopher Faulet5efdef22021-03-11 18:03:21 +01003260/*
3261 * update server status based on result of SRV resolution
3262 * returns:
3263 * 0 if server status is updated
3264 * 1 if server status has not changed
3265 *
3266 * Must be called with the server lock held.
3267 */
3268int srvrq_update_srv_status(struct server *s, int has_no_ip)
3269{
3270 if (!s->srvrq)
3271 return 1;
3272
3273 /* since this server has an IP, it can go back in production */
3274 if (has_no_ip == 0) {
3275 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3276 return 1;
3277 }
3278
3279 if (s->next_admin & SRV_ADMF_RMAINT)
3280 return 1;
3281
3282 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
3283 return 0;
3284}
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003285
3286/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003287 * update server status based on result of name resolution
3288 * returns:
3289 * 0 if server status is updated
3290 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003291 *
3292 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003293 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003294int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003295{
Emeric Brun750fe792020-12-23 16:51:12 +01003296 struct resolvers *resolvers = s->resolvers;
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003297 struct resolv_resolution *resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003298 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003299
Jerome Magnin012261a2020-07-28 13:38:22 +02003300 /* If resolution is NULL we're dealing with SRV records Additional records */
Christopher Faulet5efdef22021-03-11 18:03:21 +01003301 if (resolution == NULL)
3302 return srvrq_update_srv_status(s, has_no_ip);
Jerome Magnin012261a2020-07-28 13:38:22 +02003303
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003304 switch (resolution->status) {
3305 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003306 /* status when HAProxy has just (re)started.
3307 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003308 break;
3309
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003310 case RSLV_STATUS_VALID:
3311 /*
3312 * resume health checks
3313 * server will be turned back on if health check is safe
3314 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003315 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003316 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003317 return 1;
3318 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3319 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003320 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003321 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003322
Emeric Brun52a91d32017-08-31 14:41:55 +02003323 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003324 return 1;
3325 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3326 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3327 s->proxy->id, s->id);
3328
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003329 ha_warning("%s.\n", trash.area);
3330 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003331 return 0;
3332
3333 case RSLV_STATUS_NX:
3334 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003335 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3336 if (!tick_is_expired(exp, now_ms))
3337 break;
3338
3339 if (s->next_admin & SRV_ADMF_RMAINT)
3340 return 1;
3341 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3342 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003343
3344 case RSLV_STATUS_TIMEOUT:
3345 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003346 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3347 if (!tick_is_expired(exp, now_ms))
3348 break;
3349
3350 if (s->next_admin & SRV_ADMF_RMAINT)
3351 return 1;
3352 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3353 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003354
3355 case RSLV_STATUS_REFUSED:
3356 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003357 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3358 if (!tick_is_expired(exp, now_ms))
3359 break;
3360
3361 if (s->next_admin & SRV_ADMF_RMAINT)
3362 return 1;
3363 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3364 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003365
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003366 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003367 /* stop server if resolution failed for a long enough period */
3368 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3369 if (!tick_is_expired(exp, now_ms))
3370 break;
3371
3372 if (s->next_admin & SRV_ADMF_RMAINT)
3373 return 1;
3374 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3375 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003376 }
3377
3378 return 1;
3379}
3380
3381/*
3382 * Server Name Resolution valid response callback
3383 * It expects:
3384 * - <nameserver>: the name server which answered the valid response
3385 * - <response>: buffer containing a valid DNS response
3386 * - <response_len>: size of <response>
3387 * It performs the following actions:
3388 * - ignore response if current ip found and server family not met
3389 * - update with first new ip found if family is met and current IP is not found
3390 * returns:
3391 * 0 on error
3392 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003393 *
3394 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003395 */
Emeric Brun08622d32020-12-23 17:41:43 +01003396int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *counters)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003397{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003398 struct server *s = NULL;
Emeric Brun08622d32020-12-23 17:41:43 +01003399 struct resolv_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003400 void *serverip, *firstip;
3401 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003402 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003403 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003404 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003405
Christopher Faulet67957bd2017-09-27 11:00:59 +02003406 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003407 if (!s)
3408 return 1;
3409
Christopher Faulet49531e82021-03-10 15:07:27 +01003410 if (s->srvrq) {
Emeric Brun0c4a8a32021-06-11 10:48:45 +02003411 /* If DNS resolution is disabled ignore it.
3412 * This is the case if the server was associated to
3413 * a SRV record and this record is now expired.
Christopher Faulet49531e82021-03-10 15:07:27 +01003414 */
Emeric Brun0c4a8a32021-06-11 10:48:45 +02003415 if (s->flags & SRV_F_NO_RESOLUTION)
Christopher Faulet49531e82021-03-10 15:07:27 +01003416 return 1;
3417 }
3418
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003419 resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
Christopher Faulet49531e82021-03-10 15:07:27 +01003420 if (!resolution)
3421 return 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003422
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003423 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003424 firstip = NULL; /* pointer to the first valid response found */
3425 /* it will be used as the new IP if a change is required */
3426 firstip_sin_family = AF_UNSPEC;
3427 serverip = NULL; /* current server IP address */
3428
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003429 /* initializing server IP pointer */
3430 server_sin_family = s->addr.ss_family;
3431 switch (server_sin_family) {
3432 case AF_INET:
3433 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3434 break;
3435
3436 case AF_INET6:
3437 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3438 break;
3439
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003440 case AF_UNSPEC:
3441 break;
3442
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003443 default:
3444 goto invalid;
3445 }
3446
Emeric Brund30e9a12020-12-23 18:49:16 +01003447 ret = resolv_get_ip_from_response(&resolution->response, &s->resolv_opts,
3448 serverip, server_sin_family, &firstip,
3449 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003450
3451 switch (ret) {
Emeric Brun456de772020-12-23 18:17:31 +01003452 case RSLV_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003453 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003454
Emeric Brun456de772020-12-23 18:17:31 +01003455 case RSLV_UPD_SRVIP_NOT_FOUND:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003456 goto save_ip;
3457
Emeric Brun456de772020-12-23 18:17:31 +01003458 case RSLV_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003459 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003460 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003461
Emeric Brun456de772020-12-23 18:17:31 +01003462 case RSLV_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003463 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003464 resolution->status = RSLV_STATUS_OTHER;
Christopher Fauletb142fb42021-06-24 15:33:52 +02003465 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003466 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003467
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003468 default:
Christopher Fauletb142fb42021-06-24 15:33:52 +02003469 has_no_ip = 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003470 goto invalid;
3471
3472 }
3473
3474 save_ip:
Emeric Brun50c870e2021-01-04 10:40:46 +01003475 if (counters) {
3476 counters->update++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003477 /* save the first ip we found */
Emeric Brun50c870e2021-01-04 10:40:46 +01003478 chunk_printf(chk, "%s/%s", counters->pid, counters->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003479 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003480 else
3481 chunk_printf(chk, "DNS cache");
Christopher Faulet69beaa92021-02-16 12:07:47 +01003482 srv_update_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003483
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003484 update_status:
Christopher Faulet7c129bb2021-06-24 15:26:03 +02003485 if (!snr_update_srv_status(s, has_no_ip) && has_no_ip)
3486 memset(&s->addr, 0, sizeof(s->addr));
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003487 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003488
3489 invalid:
Emeric Brun50c870e2021-01-04 10:40:46 +01003490 if (counters) {
3491 counters->invalid++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003492 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003493 }
Christopher Fauletb142fb42021-06-24 15:33:52 +02003494 if (!snr_update_srv_status(s, has_no_ip) && has_no_ip)
3495 memset(&s->addr, 0, sizeof(s->addr));
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003496 return 0;
3497}
3498
3499/*
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003500 * SRV record error management callback
3501 * returns:
Emeric Brun43839d02021-06-10 15:25:25 +02003502 * 0 if we can trash answser items.
3503 * 1 when safely ignored and we must kept answer items
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003504 *
3505 * Grabs the server's lock.
3506 */
3507int srvrq_resolution_error_cb(struct resolv_requester *requester, int error_code)
3508{
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003509 struct resolv_srvrq *srvrq;
3510 struct resolv_resolution *res;
3511 struct resolvers *resolvers;
3512 int exp;
3513
3514 /* SRV records */
3515 srvrq = objt_resolv_srvrq(requester->owner);
3516 if (!srvrq)
Emeric Brun43839d02021-06-10 15:25:25 +02003517 return 0;
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003518
3519 resolvers = srvrq->resolvers;
3520 res = requester->resolution;
3521
3522 switch (res->status) {
3523
3524 case RSLV_STATUS_NX:
3525 /* stop server if resolution is NX for a long enough period */
3526 exp = tick_add(res->last_valid, resolvers->hold.nx);
3527 if (!tick_is_expired(exp, now_ms))
3528 return 1;
3529 break;
3530
3531 case RSLV_STATUS_TIMEOUT:
3532 /* stop server if resolution is TIMEOUT for a long enough period */
3533 exp = tick_add(res->last_valid, resolvers->hold.timeout);
3534 if (!tick_is_expired(exp, now_ms))
3535 return 1;
3536 break;
3537
3538 case RSLV_STATUS_REFUSED:
3539 /* stop server if resolution is REFUSED for a long enough period */
3540 exp = tick_add(res->last_valid, resolvers->hold.refused);
3541 if (!tick_is_expired(exp, now_ms))
3542 return 1;
3543 break;
3544
3545 default:
3546 /* stop server if resolution failed for a long enough period */
3547 exp = tick_add(res->last_valid, resolvers->hold.other);
3548 if (!tick_is_expired(exp, now_ms))
3549 return 1;
3550 }
3551
Emeric Brun0c4a8a32021-06-11 10:48:45 +02003552 /* Remove any associated server ref */
3553 resolv_detach_from_resolution_answer_items(res, requester, 1);
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003554
Emeric Brun43839d02021-06-10 15:25:25 +02003555 return 0;
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003556}
3557
3558/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003559 * Server Name Resolution error management callback
3560 * returns:
Emeric Brun43839d02021-06-10 15:25:25 +02003561 * 0 if we can trash answser items.
3562 * 1 when safely ignored and we must kept answer items
Willy Tarreau46b7f532018-08-21 11:54:26 +02003563 *
3564 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003565 */
Emeric Brun08622d32020-12-23 17:41:43 +01003566int snr_resolution_error_cb(struct resolv_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003567{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003568 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003569
Christopher Faulet67957bd2017-09-27 11:00:59 +02003570 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003571 if (!s)
Emeric Brun43839d02021-06-10 15:25:25 +02003572 return 0;
3573
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003574 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Emeric Brun43839d02021-06-10 15:25:25 +02003575 if (!snr_update_srv_status(s, 1)) {
Christopher Faulet5130c212021-03-10 20:31:40 +01003576 memset(&s->addr, 0, sizeof(s->addr));
Emeric Brun43839d02021-06-10 15:25:25 +02003577 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Emeric Brun0c4a8a32021-06-11 10:48:45 +02003578 resolv_detach_from_resolution_answer_items(requester->resolution, requester, 1);
Emeric Brun43839d02021-06-10 15:25:25 +02003579 return 0;
3580 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003581 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Emeric Brun43839d02021-06-10 15:25:25 +02003582
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003583 return 1;
3584}
3585
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003586/*
3587 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003588 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003589 * It returns a pointer to the first server found or NULL if <ip> is not yet
3590 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003591 *
3592 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003593 */
3594struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3595{
3596 struct server *tmpsrv;
3597 struct proxy *be;
3598
3599 if (!srv)
3600 return NULL;
3601
3602 be = srv->proxy;
3603 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003604 /* we found the current server is the same, ignore it */
3605 if (srv == tmpsrv)
3606 continue;
3607
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003608 /* We want to compare the IP in the record with the IP of the servers in the
3609 * same backend, only if:
3610 * * DNS resolution is enabled on the server
3611 * * the hostname used for the resolution by our server is the same than the
3612 * one used for the server found in the backend
3613 * * the server found in the backend is not our current server
3614 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003615 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003616 if ((tmpsrv->hostname_dn == NULL) ||
3617 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
Christopher Faulet59b29252021-03-16 11:21:04 +01003618 (strcasecmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01003619 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003620 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003621 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003622 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003623
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003624 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01003625 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003626 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003627 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003628 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003629
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003630 /* At this point, we have 2 different servers using the same DNS hostname
3631 * for their respective resolution.
3632 */
3633 if (*ip_family == tmpsrv->addr.ss_family &&
3634 ((tmpsrv->addr.ss_family == AF_INET &&
3635 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3636 (tmpsrv->addr.ss_family == AF_INET6 &&
3637 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003638 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003639 return tmpsrv;
3640 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003641 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003642 }
3643
Emeric Brune9fd6b52017-11-02 17:20:39 +01003644
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003645 return NULL;
3646}
3647
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003648/* Sets the server's address (srv->addr) from srv->hostname using the libc's
3649 * resolver. This is suited for initial address configuration. Returns 0 on
3650 * success otherwise a non-zero error code. In case of error, *err_code, if
3651 * not NULL, is filled up.
3652 */
3653int srv_set_addr_via_libc(struct server *srv, int *err_code)
3654{
3655 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003656 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01003657 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003658 return 1;
3659 }
3660 return 0;
3661}
3662
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003663/* Set the server's FDQN (->hostname) from <hostname>.
3664 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003665 *
3666 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003667 */
Emeric Brun08622d32020-12-23 17:41:43 +01003668int srv_set_fqdn(struct server *srv, const char *hostname, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003669{
Emeric Brun08622d32020-12-23 17:41:43 +01003670 struct resolv_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003671 char *hostname_dn;
3672 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003673
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02003674 /* Note that the server lock is already held. */
3675 if (!srv->resolvers)
3676 return -1;
3677
Emeric Brun08622d32020-12-23 17:41:43 +01003678 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003679 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003680 /* run time DNS/SRV resolution was not active for this server
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003681 * and we can't enable it at run time for now.
3682 */
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003683 if (!srv->resolv_requester && !srv->srvrq)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003684 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003685
3686 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003687 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003688 hostname_dn = trash.area;
Willy Tarreauc1c765f2021-10-14 07:49:49 +02003689 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len,
Emeric Brund30e9a12020-12-23 18:49:16 +01003690 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003691 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003692 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003693
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003694 resolution = (srv->resolv_requester ? srv->resolv_requester->resolution : NULL);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003695 if (resolution &&
3696 resolution->hostname_dn &&
Christopher Faulet59b29252021-03-16 11:21:04 +01003697 resolution->hostname_dn_len == hostname_dn_len &&
3698 strcasecmp(resolution->hostname_dn, hostname_dn) == 0)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003699 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003700
Christopher Faulet0efc0992021-03-11 18:09:53 +01003701 resolv_unlink_resolution(srv->resolv_requester, 0);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003702
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003703 free(srv->hostname);
3704 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003705 srv->hostname = strdup(hostname);
3706 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003707 srv->hostname_dn_len = hostname_dn_len;
3708 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003709 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003710
Baptiste Assmann13a92322019-06-07 09:40:55 +02003711 if (srv->flags & SRV_F_NO_RESOLUTION)
3712 goto end;
3713
Emeric Brund30e9a12020-12-23 18:49:16 +01003714 if (resolv_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003715 goto err;
3716
3717 end:
Emeric Brun08622d32020-12-23 17:41:43 +01003718 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003719 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003720 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02003721
3722 err:
Emeric Brun08622d32020-12-23 17:41:43 +01003723 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003724 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02003725 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003726}
3727
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003728/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
3729 * from the state file. This is suited for initial address configuration.
3730 * Returns 0 on success otherwise a non-zero error code. In case of error,
3731 * *err_code, if not NULL, is filled up.
3732 */
3733static int srv_apply_lastaddr(struct server *srv, int *err_code)
3734{
3735 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
3736 if (err_code)
3737 *err_code |= ERR_WARN;
3738 return 1;
3739 }
3740 return 0;
3741}
3742
Willy Tarreau25e51522016-11-04 15:10:17 +01003743/* returns 0 if no error, otherwise a combination of ERR_* flags */
3744static int srv_iterate_initaddr(struct server *srv)
3745{
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003746 char *name = srv->hostname;
Willy Tarreau25e51522016-11-04 15:10:17 +01003747 int return_code = 0;
3748 int err_code;
3749 unsigned int methods;
3750
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003751 /* If no addr and no hostname set, get the name from the DNS SRV request */
3752 if (!name && srv->srvrq)
3753 name = srv->srvrq->name;
3754
Willy Tarreau25e51522016-11-04 15:10:17 +01003755 methods = srv->init_addr_methods;
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003756 if (!methods) {
3757 /* otherwise default to "last,libc" */
Willy Tarreau25e51522016-11-04 15:10:17 +01003758 srv_append_initaddr(&methods, SRV_IADDR_LAST);
3759 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003760 if (srv->resolvers_id) {
3761 /* dns resolution is configured, add "none" to not fail on startup */
3762 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3763 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003764 }
3765
Willy Tarreau3eed10e2016-11-07 21:03:16 +01003766 /* "-dr" : always append "none" so that server addresses resolution
3767 * failures are silently ignored, this is convenient to validate some
3768 * configs out of their environment.
3769 */
3770 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
3771 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3772
Willy Tarreau25e51522016-11-04 15:10:17 +01003773 while (methods) {
3774 err_code = 0;
3775 switch (srv_get_next_initaddr(&methods)) {
3776 case SRV_IADDR_LAST:
3777 if (!srv->lastaddr)
3778 continue;
3779 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003780 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003781 return_code |= err_code;
3782 break;
3783
3784 case SRV_IADDR_LIBC:
3785 if (!srv->hostname)
3786 continue;
3787 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003788 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003789 return_code |= err_code;
3790 break;
3791
Willy Tarreau37ebe122016-11-04 15:17:58 +01003792 case SRV_IADDR_NONE:
3793 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003794 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003795 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003796 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003797 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01003798 return return_code;
3799
Willy Tarreau4310d362016-11-02 15:05:56 +01003800 case SRV_IADDR_IP:
3801 ipcpy(&srv->init_addr, &srv->addr);
3802 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003803 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 +01003804 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau4310d362016-11-02 15:05:56 +01003805 }
Olivier Houchard4e694042017-03-14 20:01:29 +01003806 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01003807
Willy Tarreau25e51522016-11-04 15:10:17 +01003808 default: /* unhandled method */
3809 break;
3810 }
3811 }
3812
3813 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003814 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003815 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau25e51522016-11-04 15:10:17 +01003816 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01003817 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003818 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003819 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003820 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003821
3822 return_code |= ERR_ALERT | ERR_FATAL;
3823 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01003824out:
3825 srv_set_dyncookie(srv);
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02003826 srv_set_addr_desc(srv, 1);
Olivier Houchard4e694042017-03-14 20:01:29 +01003827 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01003828}
3829
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003830/*
3831 * This function parses all backends and all servers within each backend
3832 * and performs servers' addr resolution based on information provided by:
3833 * - configuration file
3834 * - server-state file (states provided by an 'old' haproxy process)
3835 *
3836 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
3837 */
3838int srv_init_addr(void)
3839{
3840 struct proxy *curproxy;
3841 int return_code = 0;
3842
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003843 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003844 while (curproxy) {
3845 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003846
3847 /* servers are in backend only */
Amaury Denoyellee3c41922021-01-06 14:28:50 +01003848 if (!(curproxy->cap & PR_CAP_BE) || curproxy->disabled)
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003849 goto srv_init_addr_next;
3850
Willy Tarreau25e51522016-11-04 15:10:17 +01003851 for (srv = curproxy->srv; srv; srv = srv->next)
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003852 if (srv->hostname || srv->srvrq)
Willy Tarreau3d609a72017-09-06 14:22:45 +02003853 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003854
3855 srv_init_addr_next:
3856 curproxy = curproxy->next;
3857 }
3858
3859 return return_code;
3860}
3861
Willy Tarreau46b7f532018-08-21 11:54:26 +02003862/*
3863 * Must be called with the server lock held.
3864 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003865const 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 +02003866{
3867
Willy Tarreau83061a82018-07-13 11:56:34 +02003868 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003869
3870 msg = get_trash_chunk();
3871 chunk_reset(msg);
3872
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003873 if (server->hostname && strcmp(fqdn, server->hostname) == 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003874 chunk_appendf(msg, "no need to change the FDQN");
3875 goto out;
3876 }
3877
3878 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
3879 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
3880 goto out;
3881 }
3882
3883 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
3884 server->proxy->id, server->id, server->hostname, fqdn);
3885
Emeric Brun08622d32020-12-23 17:41:43 +01003886 if (srv_set_fqdn(server, fqdn, resolv_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003887 chunk_reset(msg);
3888 chunk_appendf(msg, "could not update %s/%s FQDN",
3889 server->proxy->id, server->id);
3890 goto out;
3891 }
3892
3893 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02003894 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003895
3896 out:
3897 if (updater)
3898 chunk_appendf(msg, " by '%s'", updater);
3899 chunk_appendf(msg, "\n");
3900
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003901 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003902}
3903
3904
Willy Tarreau21b069d2016-11-23 17:15:08 +01003905/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
3906 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01003907 * 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 +01003908 * used for CLI commands requiring a server name.
3909 * Important: the <arg> is modified to remove the '/'.
3910 */
3911struct server *cli_find_server(struct appctx *appctx, char *arg)
3912{
3913 struct proxy *px;
3914 struct server *sv;
3915 char *line;
3916
3917 /* split "backend/server" and make <line> point to server */
3918 for (line = arg; *line; line++)
3919 if (*line == '/') {
3920 *line++ = '\0';
3921 break;
3922 }
3923
3924 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003925 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003926 return NULL;
3927 }
3928
3929 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003930 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003931 return NULL;
3932 }
3933
Willy Tarreauc3914d42020-09-24 08:39:22 +02003934 if (px->disabled) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003935 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003936 return NULL;
3937 }
3938
3939 return sv;
3940}
3941
William Lallemand222baf22016-11-19 02:00:33 +01003942
Willy Tarreau46b7f532018-08-21 11:54:26 +02003943/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003944static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01003945{
3946 struct server *sv;
3947 const char *warning;
3948
3949 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3950 return 1;
3951
3952 sv = cli_find_server(appctx, args[2]);
3953 if (!sv)
3954 return 1;
3955
3956 if (strcmp(args[3], "weight") == 0) {
Christopher Faulet77df12c2021-06-15 12:01:29 +02003957 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01003958 warning = server_parse_weight_change_request(sv, args[4]);
Christopher Faulet77df12c2021-06-15 12:01:29 +02003959 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02003960 if (warning)
3961 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01003962 }
3963 else if (strcmp(args[3], "state") == 0) {
Christopher Faulet77df12c2021-06-15 12:01:29 +02003964 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01003965 if (strcmp(args[4], "ready") == 0)
3966 srv_adm_set_ready(sv);
3967 else if (strcmp(args[4], "drain") == 0)
3968 srv_adm_set_drain(sv);
3969 else if (strcmp(args[4], "maint") == 0)
3970 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02003971 else
3972 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02003973 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01003974 }
3975 else if (strcmp(args[3], "health") == 0) {
Christopher Faulet77df12c2021-06-15 12:01:29 +02003976 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02003977 if (sv->track)
3978 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003979 else if (strcmp(args[4], "up") == 0) {
3980 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003981 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003982 }
3983 else if (strcmp(args[4], "stopping") == 0) {
3984 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003985 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003986 }
3987 else if (strcmp(args[4], "down") == 0) {
3988 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02003989 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003990 }
Willy Tarreau9d008692019-08-09 11:21:01 +02003991 else
3992 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02003993 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01003994 }
3995 else if (strcmp(args[3], "agent") == 0) {
Christopher Faulet77df12c2021-06-15 12:01:29 +02003996 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02003997 if (!(sv->agent.state & CHK_ST_ENABLED))
3998 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003999 else if (strcmp(args[4], "up") == 0) {
4000 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004001 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004002 }
4003 else if (strcmp(args[4], "down") == 0) {
4004 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004005 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004006 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004007 else
4008 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004009 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004010 }
Misiek2da082d2017-01-09 09:40:42 +01004011 else if (strcmp(args[3], "agent-addr") == 0) {
William Dauchy7cabc062021-02-11 22:51:24 +01004012 char *addr = NULL;
4013 char *port = NULL;
4014 if (strlen(args[4]) == 0) {
4015 cli_err(appctx, "set server <b>/<s> agent-addr requires"
4016 " an address and optionally a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004017 goto out;
William Dauchy7cabc062021-02-11 22:51:24 +01004018 }
4019 addr = args[4];
4020 if (strcmp(args[5], "port") == 0)
4021 port = args[6];
Christopher Faulet77df12c2021-06-15 12:01:29 +02004022 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004023 warning = srv_update_agent_addr_port(sv, addr, port);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004024 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchy7cabc062021-02-11 22:51:24 +01004025 if (warning)
4026 cli_msg(appctx, LOG_WARNING, warning);
4027 }
4028 else if (strcmp(args[3], "agent-port") == 0) {
4029 char *port = NULL;
4030 if (strlen(args[4]) == 0) {
4031 cli_err(appctx, "set server <b>/<s> agent-port requires"
4032 " a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004033 goto out;
William Dauchy7cabc062021-02-11 22:51:24 +01004034 }
4035 port = args[4];
Christopher Faulet77df12c2021-06-15 12:01:29 +02004036 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004037 warning = srv_update_agent_addr_port(sv, NULL, port);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004038 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchy7cabc062021-02-11 22:51:24 +01004039 if (warning)
4040 cli_msg(appctx, LOG_WARNING, warning);
Misiek2da082d2017-01-09 09:40:42 +01004041 }
4042 else if (strcmp(args[3], "agent-send") == 0) {
Christopher Faulet88fca372021-06-18 08:47:14 +02004043 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02004044 if (!(sv->agent.state & CHK_ST_ENABLED))
4045 cli_err(appctx, "agent checks are not enabled on this server.\n");
4046 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02004047 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02004048 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01004049 }
Christopher Faulet88fca372021-06-18 08:47:14 +02004050 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Misiek2da082d2017-01-09 09:40:42 +01004051 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004052 else if (strcmp(args[3], "check-addr") == 0) {
4053 char *addr = NULL;
4054 char *port = NULL;
4055 if (strlen(args[4]) == 0) {
4056 cli_err(appctx, "set server <b>/<s> check-addr requires"
4057 " an address and optionally a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004058 goto out;
William Lallemand222baf22016-11-19 02:00:33 +01004059 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004060 addr = args[4];
4061 if (strcmp(args[5], "port") == 0)
4062 port = args[6];
Christopher Faulet77df12c2021-06-15 12:01:29 +02004063 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004064 warning = srv_update_check_addr_port(sv, addr, port);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004065 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchyb456e1f2021-02-11 22:51:23 +01004066 if (warning)
4067 cli_msg(appctx, LOG_WARNING, warning);
4068 }
4069 else if (strcmp(args[3], "check-port") == 0) {
4070 char *port = NULL;
4071 if (strlen(args[4]) == 0) {
4072 cli_err(appctx, "set server <b>/<s> check-port requires"
4073 " a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004074 goto out;
William Lallemand222baf22016-11-19 02:00:33 +01004075 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004076 port = args[4];
Christopher Faulet77df12c2021-06-15 12:01:29 +02004077 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004078 warning = srv_update_check_addr_port(sv, NULL, port);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004079 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchyb456e1f2021-02-11 22:51:23 +01004080 if (warning)
4081 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004082 }
4083 else if (strcmp(args[3], "addr") == 0) {
4084 char *addr = NULL;
4085 char *port = NULL;
4086 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004087 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004088 goto out;
William Lallemand222baf22016-11-19 02:00:33 +01004089 }
4090 else {
4091 addr = args[4];
4092 }
4093 if (strcmp(args[5], "port") == 0) {
4094 port = args[6];
4095 }
Christopher Faulet77df12c2021-06-15 12:01:29 +02004096 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004097 warning = srv_update_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02004098 if (warning)
4099 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004100 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004101 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004102 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004103 else if (strcmp(args[3], "fqdn") == 0) {
4104 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004105 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004106 goto out;
4107 }
4108 if (!sv->resolvers) {
4109 cli_err(appctx, "set server <b>/<s> fqdn failed because no resolution is configured.\n");
4110 goto out;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004111 }
Christopher Faulet5b04f462021-06-15 11:37:40 +02004112 if (sv->srvrq) {
4113 cli_err(appctx, "set server <b>/<s> fqdn failed because SRV resolution is configured.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004114 goto out;
Christopher Faulet5b04f462021-06-15 11:37:40 +02004115 }
Christopher Faulet77df12c2021-06-15 12:01:29 +02004116 HA_SPIN_LOCK(DNS_LOCK, &sv->resolvers->lock);
4117 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Baptiste Assmann13a92322019-06-07 09:40:55 +02004118 /* ensure runtime resolver will process this new fqdn */
4119 if (sv->flags & SRV_F_NO_RESOLUTION) {
4120 sv->flags &= ~SRV_F_NO_RESOLUTION;
4121 }
Christopher Faulet77df12c2021-06-15 12:01:29 +02004122 warning = srv_update_fqdn(sv, args[4], "stats socket command", 1);
Christopher Faulet88fca372021-06-18 08:47:14 +02004123 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004124 HA_SPIN_UNLOCK(DNS_LOCK, &sv->resolvers->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02004125 if (warning)
4126 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004127 }
William Dauchyf6370442020-11-14 19:25:33 +01004128 else if (strcmp(args[3], "ssl") == 0) {
4129#ifdef USE_OPENSSL
4130 if (sv->ssl_ctx.ctx == NULL) {
4131 cli_err(appctx, "'set server <srv> ssl' cannot be set. "
4132 " default-server should define ssl settings\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004133 goto out;
4134 }
4135
4136 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4137 if (strcmp(args[4], "on") == 0) {
William Dauchyf6370442020-11-14 19:25:33 +01004138 ssl_sock_set_srv(sv, 1);
4139 } else if (strcmp(args[4], "off") == 0) {
4140 ssl_sock_set_srv(sv, 0);
4141 } else {
Christopher Faulet77df12c2021-06-15 12:01:29 +02004142 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchyf6370442020-11-14 19:25:33 +01004143 cli_err(appctx, "'set server <srv> ssl' expects 'on' or 'off'.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004144 goto out;
William Dauchyf6370442020-11-14 19:25:33 +01004145 }
4146 srv_cleanup_connections(sv);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004147 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchyf6370442020-11-14 19:25:33 +01004148 cli_msg(appctx, LOG_NOTICE, "server ssl setting updated.\n");
4149#else
4150 cli_msg(appctx, LOG_NOTICE, "server ssl setting not supported.\n");
4151#endif
4152 } else {
Willy Tarreau9d008692019-08-09 11:21:01 +02004153 cli_err(appctx,
William Dauchy3f4ec7d2021-02-15 17:22:16 +01004154 "usage: set server <backend>/<server> "
4155 "addr | agent | agent-addr | agent-port | agent-send | "
4156 "check-addr | check-port | fqdn | health | ssl | "
4157 "state | weight\n");
William Lallemand222baf22016-11-19 02:00:33 +01004158 }
Christopher Faulet77df12c2021-06-15 12:01:29 +02004159 out:
William Lallemand222baf22016-11-19 02:00:33 +01004160 return 1;
4161}
4162
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004163static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004164{
4165 struct stream_interface *si = appctx->owner;
4166 struct proxy *px;
4167 struct server *sv;
4168 char *line;
4169
4170
4171 /* split "backend/server" and make <line> point to server */
4172 for (line = args[2]; *line; line++)
4173 if (*line == '/') {
4174 *line++ = '\0';
4175 break;
4176 }
4177
Willy Tarreau9d008692019-08-09 11:21:01 +02004178 if (!*line)
4179 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004180
Willy Tarreau9d008692019-08-09 11:21:01 +02004181 if (!get_backend_server(args[2], line, &px, &sv))
4182 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004183
4184 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004185 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
4186 sv->iweight);
4187 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004188 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004189 return 0;
4190 }
William Lallemand6b160942016-11-22 12:34:35 +01004191 return 1;
4192}
4193
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004194/* Parse a "set weight" command.
4195 *
4196 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004197 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004198static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004199{
4200 struct server *sv;
4201 const char *warning;
4202
4203 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4204 return 1;
4205
4206 sv = cli_find_server(appctx, args[2]);
4207 if (!sv)
4208 return 1;
4209
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004210 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4211
William Lallemand6b160942016-11-22 12:34:35 +01004212 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004213 if (warning)
4214 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004215
4216 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4217
William Lallemand6b160942016-11-22 12:34:35 +01004218 return 1;
4219}
4220
Willy Tarreau46b7f532018-08-21 11:54:26 +02004221/* parse a "set maxconn server" command. It always returns 1.
4222 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004223 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004224 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004225static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01004226{
4227 struct server *sv;
4228 const char *warning;
4229
4230 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4231 return 1;
4232
4233 sv = cli_find_server(appctx, args[3]);
4234 if (!sv)
4235 return 1;
4236
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02004237 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4238
Willy Tarreaub8026272016-11-23 11:26:56 +01004239 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004240 if (warning)
4241 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004242
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02004243 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4244
Willy Tarreaub8026272016-11-23 11:26:56 +01004245 return 1;
4246}
William Lallemand6b160942016-11-22 12:34:35 +01004247
Willy Tarreau46b7f532018-08-21 11:54:26 +02004248/* parse a "disable agent" command. It always returns 1.
4249 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004250 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004251 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004252static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004253{
4254 struct server *sv;
4255
4256 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4257 return 1;
4258
4259 sv = cli_find_server(appctx, args[2]);
4260 if (!sv)
4261 return 1;
4262
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004263 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004264 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004265 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004266 return 1;
4267}
4268
Willy Tarreau46b7f532018-08-21 11:54:26 +02004269/* parse a "disable health" command. It always returns 1.
4270 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004271 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004272 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004273static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004274{
4275 struct server *sv;
4276
4277 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4278 return 1;
4279
4280 sv = cli_find_server(appctx, args[2]);
4281 if (!sv)
4282 return 1;
4283
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004284 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004285 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004286 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004287 return 1;
4288}
4289
Willy Tarreau46b7f532018-08-21 11:54:26 +02004290/* parse a "disable server" command. It always returns 1.
4291 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004292 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004293 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004294static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004295{
4296 struct server *sv;
4297
4298 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4299 return 1;
4300
4301 sv = cli_find_server(appctx, args[2]);
4302 if (!sv)
4303 return 1;
4304
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004305 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004306 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004307 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004308 return 1;
4309}
4310
Willy Tarreau46b7f532018-08-21 11:54:26 +02004311/* parse a "enable agent" command. It always returns 1.
4312 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004313 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004314 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004315static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004316{
4317 struct server *sv;
4318
4319 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4320 return 1;
4321
4322 sv = cli_find_server(appctx, args[2]);
4323 if (!sv)
4324 return 1;
4325
Willy Tarreau9d008692019-08-09 11:21:01 +02004326 if (!(sv->agent.state & CHK_ST_CONFIGURED))
4327 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004328
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004329 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004330 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004331 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004332 return 1;
4333}
4334
Willy Tarreau46b7f532018-08-21 11:54:26 +02004335/* parse a "enable health" command. It always returns 1.
4336 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004337 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004338 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004339static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004340{
4341 struct server *sv;
4342
4343 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4344 return 1;
4345
4346 sv = cli_find_server(appctx, args[2]);
4347 if (!sv)
4348 return 1;
4349
Amaury Denoyellee636a112021-09-21 10:29:09 +02004350 if (!(sv->check.state & CHK_ST_CONFIGURED))
4351 return cli_err(appctx, "Health check was not configured on this server, cannot enable.\n");
4352
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004353 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004354 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004355 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004356 return 1;
4357}
4358
Willy Tarreau46b7f532018-08-21 11:54:26 +02004359/* parse a "enable server" command. It always returns 1.
4360 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004361 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004362 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004363static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004364{
4365 struct server *sv;
4366
4367 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4368 return 1;
4369
4370 sv = cli_find_server(appctx, args[2]);
4371 if (!sv)
4372 return 1;
4373
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004374 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004375 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004376 if (!(sv->flags & SRV_F_COOKIESET)
4377 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4378 sv->cookie)
4379 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004380 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004381 return 1;
4382}
4383
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004384/* Allocates data structure related to load balancing for the server <sv>. It
4385 * is only required for dynamic servers.
4386 *
4387 * At the moment, the server lock is not used as this function is only called
4388 * for a dynamic server not yet registered.
4389 *
4390 * Returns 1 on success, 0 on allocation failure.
4391 */
4392static int srv_alloc_lb(struct server *sv, struct proxy *be)
4393{
4394 int node;
4395
4396 sv->lb_tree = (sv->flags & SRV_F_BACKUP) ?
4397 &be->lbprm.chash.bck : &be->lbprm.chash.act;
4398 sv->lb_nodes_tot = sv->uweight * BE_WEIGHT_SCALE;
4399 sv->lb_nodes_now = 0;
4400
Willy Tarreaudcb121f2021-04-20 11:37:45 +02004401 if (((be->lbprm.algo & (BE_LB_KIND | BE_LB_PARM)) == (BE_LB_KIND_RR | BE_LB_RR_RANDOM)) ||
4402 ((be->lbprm.algo & (BE_LB_KIND | BE_LB_HASH_TYPE)) == (BE_LB_KIND_HI | BE_LB_HASH_CONS))) {
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004403 sv->lb_nodes = calloc(sv->lb_nodes_tot, sizeof(*sv->lb_nodes));
4404
4405 if (!sv->lb_nodes)
4406 return 0;
4407
4408 for (node = 0; node < sv->lb_nodes_tot; node++) {
4409 sv->lb_nodes[node].server = sv;
4410 sv->lb_nodes[node].node.key = full_hash(sv->puid * SRV_EWGHT_RANGE + node);
4411 }
4412 }
4413
4414 return 1;
4415}
4416
4417/* Parse a "add server" command
4418 * Returns 0 if the server has been successfully initialized, 1 on failure.
4419 */
4420static int cli_parse_add_server(char **args, char *payload, struct appctx *appctx, void *private)
4421{
4422 struct proxy *be;
4423 struct server *srv;
4424 char *be_name, *sv_name;
4425 char *errmsg = NULL;
4426 int errcode, argc;
Amaury Denoyelle12173562021-06-09 09:58:47 +02004427 int next_id, i;
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004428 const int parse_flags = SRV_PARSE_DYNAMIC|SRV_PARSE_PARSE_ADDR;
4429
4430 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4431 return 1;
4432
4433 ++args;
4434
4435 sv_name = be_name = args[1];
4436 /* split backend/server arg */
4437 while (*sv_name && *(++sv_name)) {
4438 if (*sv_name == '/') {
4439 *sv_name = '\0';
4440 ++sv_name;
4441 break;
4442 }
4443 }
4444
4445 if (!*sv_name)
4446 return cli_err(appctx, "Require 'backend/server'.");
4447
Amaury Denoyellecece9182021-04-20 17:09:08 +02004448 be = proxy_be_by_name(be_name);
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004449 if (!be)
4450 return cli_err(appctx, "No such backend.");
4451
4452 if (!(be->lbprm.algo & BE_LB_PROP_DYN)) {
Amaury Denoyelleeafd7012021-04-29 14:59:42 +02004453 cli_err(appctx, "Backend must use a dynamic load balancing to support dynamic servers.");
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004454 return 1;
4455 }
4456
Amaury Denoyelled50d4bf2021-06-10 15:26:44 +02004457 /* At this point, some operations might not be thread-safe anymore. This
4458 * might be the case for parsing handlers which were designed to run
4459 * only at the starting stage on single-thread mode.
4460 *
4461 * Activate thread isolation to ensure thread-safety.
4462 */
4463 thread_isolate();
4464
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004465 args[1] = sv_name;
4466 errcode = _srv_parse_init(&srv, args, &argc, be, parse_flags, &errmsg);
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02004467 if (srv)
4468 srv_use_dynsrv(srv);
4469
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004470 if (errcode) {
4471 if (errmsg)
4472 cli_dynerr(appctx, errmsg);
4473 goto out;
4474 }
4475
4476 while (*args[argc]) {
4477 errcode = _srv_parse_kw(srv, args, &argc, be, parse_flags, &errmsg);
4478
4479 if (errcode) {
4480 if (errmsg)
4481 cli_dynerr(appctx, errmsg);
4482 goto out;
4483 }
4484 }
4485
4486 _srv_parse_finalize(args, argc, srv, be, parse_flags, &errmsg);
4487 if (errmsg) {
4488 cli_dynerr(appctx, errmsg);
4489 goto out;
4490 }
4491
Amaury Denoyellee9bb7fb2021-06-10 17:34:10 +02004492 /* A dynamic server does not currently support resolution.
4493 *
4494 * Initialize it explicitly to the "none" method to ensure no
4495 * resolution will ever be executed.
4496 */
4497 srv->init_addr_methods = SRV_IADDR_NONE;
4498
Amaury Denoyelle30467232021-03-12 18:03:27 +01004499 if (srv->mux_proto) {
4500 if (!conn_get_best_mux_entry(srv->mux_proto->token, PROTO_SIDE_BE, be->mode)) {
4501 cli_err(appctx, "MUX protocol is not usable for server.");
4502 goto out;
4503 }
4504 }
4505
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004506 srv->per_thr = calloc(global.nbthread, sizeof(*srv->per_thr));
4507 if (!srv->per_thr) {
4508 cli_err(appctx, "failed to allocate per-thread lists for server.");
4509 goto out;
4510 }
4511
4512 for (i = 0; i < global.nbthread; i++) {
4513 srv->per_thr[i].idle_conns = EB_ROOT;
4514 srv->per_thr[i].safe_conns = EB_ROOT;
4515 srv->per_thr[i].avail_conns = EB_ROOT;
4516 MT_LIST_INIT(&srv->per_thr[i].streams);
4517 }
4518
4519 if (srv->max_idle_conns != 0) {
4520 srv->curr_idle_thr = calloc(global.nbthread, sizeof(*srv->curr_idle_thr));
4521 if (!srv->curr_idle_thr) {
4522 cli_err(appctx, "failed to allocate counters for server.");
4523 goto out;
4524 }
4525 }
4526
4527 if (!srv_alloc_lb(srv, be)) {
4528 cli_err(appctx, "Failed to initialize load-balancing data.");
4529 goto out;
4530 }
4531
4532 if (!stats_allocate_proxy_counters_internal(&srv->extra_counters,
4533 COUNTERS_SV,
4534 STATS_PX_CAP_SRV)) {
4535 cli_err(appctx, "failed to allocate extra counters for server.");
4536 goto out;
4537 }
4538
Amaury Denoyelled50d4bf2021-06-10 15:26:44 +02004539 /* Attach the server to the end of the proxy linked list. Note that this
4540 * operation is not thread-safe so this is executed under thread
4541 * isolation.
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004542 *
Amaury Denoyelled50d4bf2021-06-10 15:26:44 +02004543 * If a server with the same name is found, reject the new one.
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004544 */
Amaury Denoyellecece9182021-04-20 17:09:08 +02004545
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004546 /* TODO use a double-linked list for px->srv */
4547 if (be->srv) {
Amaury Denoyellecece9182021-04-20 17:09:08 +02004548 struct server *next = be->srv;
4549
4550 while (1) {
4551 /* check for duplicate server */
4552 if (!strcmp(srv->id, next->id)) {
Amaury Denoyellecece9182021-04-20 17:09:08 +02004553 cli_err(appctx, "Already exists a server with the same name in backend.");
4554 goto out;
4555 }
4556
4557 if (!next->next)
4558 break;
4559
4560 next = next->next;
4561 }
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004562
4563 next->next = srv;
4564 }
4565 else {
4566 srv->next = be->srv;
4567 be->srv = srv;
4568 }
Amaury Denoyellecece9182021-04-20 17:09:08 +02004569
Amaury Denoyelle12173562021-06-09 09:58:47 +02004570 /* generate the server id if not manually specified */
4571 if (!srv->puid) {
4572 next_id = get_next_id(&be->conf.used_server_id, 1);
4573 if (!next_id) {
4574 ha_alert("Cannot attach server : no id left in proxy\n");
4575 goto out;
4576 }
4577
4578 srv->conf.id.key = srv->puid = next_id;
4579 srv->conf.name.key = srv->id;
4580 }
4581
4582 /* insert the server in the backend trees */
Amaury Denoyellef88af882021-06-08 17:00:20 +02004583 eb32_insert(&be->conf.used_server_id, &srv->conf.id);
4584 ebis_insert(&be->conf.used_server_name, &srv->conf.name);
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02004585 ebis_insert(&be->used_server_addr, &srv->addr_node);
Amaury Denoyelle12173562021-06-09 09:58:47 +02004586
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004587 thread_release();
4588
Amaury Denoyelled38e7fa2021-04-20 18:35:19 +02004589 ha_notice("New server %s/%s registered.\n", be->id, srv->id);
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004590 cli_msg(appctx, LOG_INFO, "New server registered.");
4591
4592 return 0;
4593
4594out:
Amaury Denoyelledb130872021-08-04 11:20:05 +02004595 if (srv) {
4596 /* remove the server from the proxy linked list */
4597 if (be->srv == srv) {
4598 be->srv = srv->next;
4599 }
4600 else {
4601 struct server *prev;
4602 for (prev = be->srv; prev && prev->next != srv; prev = prev->next)
4603 ;
4604 if (prev)
4605 prev->next = srv->next;
4606 }
4607
4608 }
4609
Amaury Denoyelled50d4bf2021-06-10 15:26:44 +02004610 thread_release();
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004611 if (srv)
4612 free_server(srv);
4613 return 1;
4614}
4615
Amaury Denoyellee5580432021-04-15 14:41:20 +02004616/* Parse a "del server" command
4617 * Returns 0 if the server has been successfully initialized, 1 on failure.
4618 */
4619static int cli_parse_delete_server(char **args, char *payload, struct appctx *appctx, void *private)
4620{
4621 struct proxy *be;
4622 struct server *srv;
4623 char *be_name, *sv_name;
4624
4625 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4626 return 1;
4627
4628 ++args;
4629
4630 sv_name = be_name = args[1];
4631 /* split backend/server arg */
4632 while (*sv_name && *(++sv_name)) {
4633 if (*sv_name == '/') {
4634 *sv_name = '\0';
4635 ++sv_name;
4636 break;
4637 }
4638 }
4639
4640 if (!*sv_name)
4641 return cli_err(appctx, "Require 'backend/server'.");
4642
4643 /* The proxy servers list is currently not protected by a lock so this
4644 * requires thread isolation.
4645 */
4646
4647 /* WARNING there is maybe a potential violation of the thread isolation
4648 * mechanism by the pool allocator. The allocator marks the thread as
4649 * harmless before the allocation, but a processing outside of it could
4650 * relies on a particular server triggered at the same time by a
4651 * 'delete server'. Currently, it is unknown if such case is present in
4652 * the current code. If it happens to be, the thread isolation
4653 * mechanism should be improved, maybe with a differentiation between
4654 * read and read+write safe sections.
4655 */
4656 thread_isolate();
4657
4658 get_backend_server(be_name, sv_name, &be, &srv);
4659 if (!be) {
4660 cli_err(appctx, "No such backend.");
4661 goto out;
4662 }
4663
4664 if (!srv) {
4665 cli_err(appctx, "No such server.");
4666 goto out;
4667 }
4668
4669 if (!(srv->flags & SRV_F_DYNAMIC)) {
4670 cli_err(appctx, "Only servers added at runtime via <add server> CLI cmd can be deleted.");
4671 goto out;
4672 }
4673
4674 /* Only servers in maintenance can be deleted. This ensures that the
4675 * server is not present anymore in the lb structures (through
4676 * lbprm.set_server_status_down).
4677 */
4678 if (!(srv->cur_admin & SRV_ADMF_MAINT)) {
4679 cli_err(appctx, "Only servers in maintenance mode can be deleted.");
4680 goto out;
4681 }
4682
4683 /* Ensure that there is no active/idle/pending connection on the server.
4684 *
4685 * TODO idle connections should not prevent server deletion. A proper
4686 * cleanup function should be implemented to be used here.
4687 */
4688 if (srv->cur_sess || srv->curr_idle_conns ||
4689 !eb_is_empty(&srv->pendconns)) {
4690 cli_err(appctx, "Server still has connections attached to it, cannot remove it.");
4691 goto out;
4692 }
4693
4694 /* TODO remove server for check list once 'check' will be implemented for
4695 * dynamic servers
4696 */
4697
4698 /* detach the server from the proxy linked list
4699 * The proxy servers list is currently not protected by a lock, so this
4700 * requires thread_isolate/release.
4701 */
4702
4703 /* be->srv cannot be empty since we have already found the server with
4704 * get_backend_server */
4705 BUG_ON(!be->srv);
4706 if (be->srv == srv) {
4707 be->srv = srv->next;
4708 }
4709 else {
4710 struct server *next;
Amaury Denoyelled6b4b6d2021-04-21 11:50:26 +02004711 for (next = be->srv; srv != next->next; next = next->next) {
4712 /* srv cannot be not found since we have already found
4713 * it with get_backend_server */
4714 BUG_ON(!next);
4715 }
Amaury Denoyellee5580432021-04-15 14:41:20 +02004716
Amaury Denoyellee5580432021-04-15 14:41:20 +02004717 next->next = srv->next;
4718 }
4719
4720 /* remove srv from addr_node tree */
Amaury Denoyelle40ad9f42021-06-09 16:00:43 +02004721 eb32_delete(&srv->conf.id);
4722 ebpt_delete(&srv->conf.name);
Amaury Denoyellee5580432021-04-15 14:41:20 +02004723 ebpt_delete(&srv->addr_node);
4724
4725 /* remove srv from idle_node tree for idle conn cleanup */
4726 eb32_delete(&srv->idle_node);
4727
4728 thread_release();
4729
4730 ha_notice("Server %s/%s deleted.\n", be->id, srv->id);
4731 free_server(srv);
4732
4733 cli_msg(appctx, LOG_INFO, "Server deleted.");
4734
4735 return 0;
4736
4737out:
4738 thread_release();
4739
4740 return 1;
4741}
4742
William Lallemand222baf22016-11-19 02:00:33 +01004743/* register cli keywords */
4744static struct cli_kw_list cli_kws = {{ },{
Amaury Denoyellec59faa52021-08-03 18:05:37 +02004745 { { "disable", "agent", NULL }, "disable agent : disable agent checks", cli_parse_disable_agent, NULL },
4746 { { "disable", "health", NULL }, "disable health : disable health checks", cli_parse_disable_health, NULL },
Willy Tarreaub205bfd2021-05-07 11:38:37 +02004747 { { "disable", "server", NULL }, "disable server (DEPRECATED) : disable a server for maintenance (use 'set server' instead)", cli_parse_disable_server, NULL },
Amaury Denoyellec59faa52021-08-03 18:05:37 +02004748 { { "enable", "agent", NULL }, "enable agent : enable agent checks", cli_parse_enable_agent, NULL },
4749 { { "enable", "health", NULL }, "enable health : enable health checks", cli_parse_enable_health, NULL },
Willy Tarreaub205bfd2021-05-07 11:38:37 +02004750 { { "enable", "server", NULL }, "enable server (DEPRECATED) : enable a disabled server (use 'set server' instead)", cli_parse_enable_server, NULL },
4751 { { "set", "maxconn", "server", NULL }, "set maxconn server <bk>/<srv> : change a server's maxconn setting", cli_parse_set_maxconn_server, NULL },
4752 { { "set", "server", NULL }, "set server <bk>/<srv> [opts] : change a server's state, weight, address or ssl", cli_parse_set_server },
4753 { { "get", "weight", NULL }, "get weight <bk>/<srv> : report a server's current weight", cli_parse_get_weight },
4754 { { "set", "weight", NULL }, "set weight <bk>/<srv> (DEPRECATED) : change a server's weight (use 'set server' instead)", cli_parse_set_weight },
4755 { { "add", "server", NULL }, "add server <bk>/<srv> : create a new server (EXPERIMENTAL)", cli_parse_add_server, NULL, NULL, NULL, ACCESS_EXPERIMENTAL },
4756 { { "del", "server", NULL }, "del server <bk>/<srv> : remove a dynamically added server (EXPERIMENTAL)", cli_parse_delete_server, NULL, NULL, NULL, ACCESS_EXPERIMENTAL },
William Lallemand222baf22016-11-19 02:00:33 +01004757 {{},}
4758}};
4759
Willy Tarreau0108d902018-11-25 19:14:37 +01004760INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004761
Emeric Brun64cc49c2017-10-03 14:46:45 +02004762/*
4763 * This function applies server's status changes, it is
4764 * is designed to be called asynchronously.
4765 *
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004766 * Must be called with the server lock held. This may also be called at init
4767 * time as the result of parsing the state file, in which case no lock will be
4768 * held, and the server's warmup task can be null.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004769 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004770static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004771{
4772 struct check *check = &s->check;
4773 int xferred;
4774 struct proxy *px = s->proxy;
4775 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4776 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4777 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004778 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004779
Emeric Brun64cc49c2017-10-03 14:46:45 +02004780 /* If currently main is not set we try to apply pending state changes */
4781 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4782 int next_admin;
4783
4784 /* Backup next admin */
4785 next_admin = s->next_admin;
4786
4787 /* restore current admin state */
4788 s->next_admin = s->cur_admin;
4789
4790 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4791 s->last_change = now.tv_sec;
4792 if (s->proxy->lbprm.set_server_status_down)
4793 s->proxy->lbprm.set_server_status_down(s);
4794
4795 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4796 srv_shutdown_streams(s, SF_ERR_DOWN);
4797
4798 /* we might have streams queued on this server and waiting for
4799 * a connection. Those which are redispatchable will be queued
4800 * to another server or to the proxy itself.
4801 */
4802 xferred = pendconn_redistribute(s);
4803
4804 tmptrash = alloc_trash_chunk();
4805 if (tmptrash) {
4806 chunk_printf(tmptrash,
4807 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4808 s->proxy->id, s->id);
4809
Emeric Brun5a133512017-10-19 14:42:30 +02004810 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004811 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004812
4813 /* we don't send an alert if the server was previously paused */
4814 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004815 send_log(s->proxy, log_level, "%s.\n",
4816 tmptrash->area);
4817 send_email_alert(s, log_level, "%s",
4818 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004819 free_trash_chunk(tmptrash);
4820 tmptrash = NULL;
4821 }
4822 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4823 set_backend_down(s->proxy);
4824
4825 s->counters.down_trans++;
4826 }
4827 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4828 s->last_change = now.tv_sec;
4829 if (s->proxy->lbprm.set_server_status_down)
4830 s->proxy->lbprm.set_server_status_down(s);
4831
4832 /* we might have streams queued on this server and waiting for
4833 * a connection. Those which are redispatchable will be queued
4834 * to another server or to the proxy itself.
4835 */
4836 xferred = pendconn_redistribute(s);
4837
4838 tmptrash = alloc_trash_chunk();
4839 if (tmptrash) {
4840 chunk_printf(tmptrash,
4841 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4842 s->proxy->id, s->id);
4843
Emeric Brun5a133512017-10-19 14:42:30 +02004844 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004845
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004846 ha_warning("%s.\n", tmptrash->area);
4847 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4848 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004849 free_trash_chunk(tmptrash);
4850 tmptrash = NULL;
4851 }
4852
4853 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4854 set_backend_down(s->proxy);
4855 }
4856 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4857 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4858 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4859 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4860 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4861 s->proxy->last_change = now.tv_sec;
4862 }
4863
Amaury Denoyellefe2bf092020-10-29 15:59:04 +01004864 if (s->cur_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
Emeric Brun64cc49c2017-10-03 14:46:45 +02004865 s->down_time += now.tv_sec - s->last_change;
4866
4867 s->last_change = now.tv_sec;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004868 if (s->next_state == SRV_ST_STARTING && s->warmup)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004869 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4870
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004871 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004872 /* now propagate the status change to any LB algorithms */
4873 if (px->lbprm.update_server_eweight)
4874 px->lbprm.update_server_eweight(s);
4875 else if (srv_willbe_usable(s)) {
4876 if (px->lbprm.set_server_status_up)
4877 px->lbprm.set_server_status_up(s);
4878 }
4879 else {
4880 if (px->lbprm.set_server_status_down)
4881 px->lbprm.set_server_status_down(s);
4882 }
4883
4884 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4885 * and it's not a backup server and its effective weight is > 0,
4886 * then it can accept new connections, so we shut down all streams
4887 * on all backup servers.
4888 */
4889 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4890 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4891 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4892
4893 /* check if we can handle some connections queued at the proxy. We
4894 * will take as many as we can handle.
4895 */
4896 xferred = pendconn_grab_from_px(s);
4897
4898 tmptrash = alloc_trash_chunk();
4899 if (tmptrash) {
4900 chunk_printf(tmptrash,
4901 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4902 s->proxy->id, s->id);
4903
Emeric Brun5a133512017-10-19 14:42:30 +02004904 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004905 ha_warning("%s.\n", tmptrash->area);
4906 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4907 tmptrash->area);
4908 send_email_alert(s, LOG_NOTICE, "%s",
4909 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004910 free_trash_chunk(tmptrash);
4911 tmptrash = NULL;
4912 }
4913
4914 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4915 set_backend_down(s->proxy);
4916 }
4917 else if (s->cur_eweight != s->next_eweight) {
4918 /* now propagate the status change to any LB algorithms */
4919 if (px->lbprm.update_server_eweight)
4920 px->lbprm.update_server_eweight(s);
4921 else if (srv_willbe_usable(s)) {
4922 if (px->lbprm.set_server_status_up)
4923 px->lbprm.set_server_status_up(s);
4924 }
4925 else {
4926 if (px->lbprm.set_server_status_down)
4927 px->lbprm.set_server_status_down(s);
4928 }
4929
4930 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4931 set_backend_down(s->proxy);
4932 }
4933
4934 s->next_admin = next_admin;
4935 }
4936
Emeric Brun5a133512017-10-19 14:42:30 +02004937 /* reset operational state change */
4938 *s->op_st_chg.reason = 0;
4939 s->op_st_chg.status = s->op_st_chg.code = -1;
4940 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004941
4942 /* Now we try to apply pending admin changes */
4943
4944 /* Maintenance must also disable health checks */
4945 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4946 if (s->check.state & CHK_ST_ENABLED) {
4947 s->check.state |= CHK_ST_PAUSED;
4948 check->health = 0;
4949 }
4950
4951 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004952 tmptrash = alloc_trash_chunk();
4953 if (tmptrash) {
4954 chunk_printf(tmptrash,
4955 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4956 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4957 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004958
Olivier Houchard796a2b32017-10-24 17:42:47 +02004959 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004960
Olivier Houchard796a2b32017-10-24 17:42:47 +02004961 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004962 ha_warning("%s.\n", tmptrash->area);
4963 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4964 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004965 }
4966 free_trash_chunk(tmptrash);
4967 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004968 }
Emeric Brun8f298292017-12-06 16:47:17 +01004969 /* commit new admin status */
4970
4971 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004972 }
4973 else { /* server was still running */
4974 check->health = 0; /* failure */
4975 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004976
4977 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004978 if (s->proxy->lbprm.set_server_status_down)
4979 s->proxy->lbprm.set_server_status_down(s);
4980
Emeric Brun64cc49c2017-10-03 14:46:45 +02004981 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4982 srv_shutdown_streams(s, SF_ERR_DOWN);
4983
William Dauchy6318d332020-05-02 21:52:36 +02004984 /* force connection cleanup on the given server */
4985 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004986 /* we might have streams queued on this server and waiting for
4987 * a connection. Those which are redispatchable will be queued
4988 * to another server or to the proxy itself.
4989 */
4990 xferred = pendconn_redistribute(s);
4991
4992 tmptrash = alloc_trash_chunk();
4993 if (tmptrash) {
4994 chunk_printf(tmptrash,
4995 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
4996 s->flags & SRV_F_BACKUP ? "Backup " : "",
4997 s->proxy->id, s->id,
4998 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4999
5000 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
5001
5002 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005003 ha_warning("%s.\n", tmptrash->area);
5004 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
5005 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005006 }
5007 free_trash_chunk(tmptrash);
5008 tmptrash = NULL;
5009 }
5010 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5011 set_backend_down(s->proxy);
5012
5013 s->counters.down_trans++;
5014 }
5015 }
5016 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
5017 /* OK here we're leaving maintenance, we have many things to check,
5018 * because the server might possibly be coming back up depending on
5019 * its state. In practice, leaving maintenance means that we should
5020 * immediately turn to UP (more or less the slowstart) under the
5021 * following conditions :
5022 * - server is neither checked nor tracked
5023 * - server tracks another server which is not checked
5024 * - server tracks another server which is already up
5025 * Which sums up as something simpler :
5026 * "either the tracking server is up or the server's checks are disabled
5027 * or up". Otherwise we only re-enable health checks. There's a special
5028 * case associated to the stopping state which can be inherited. Note
5029 * that the server might still be in drain mode, which is naturally dealt
5030 * with by the lower level functions.
5031 */
5032
5033 if (s->check.state & CHK_ST_ENABLED) {
5034 s->check.state &= ~CHK_ST_PAUSED;
5035 check->health = check->rise; /* start OK but check immediately */
5036 }
5037
5038 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
5039 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
5040 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
5041 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
5042 s->next_state = SRV_ST_STOPPING;
5043 }
5044 else {
Willy Tarreauf79c4cf2021-08-04 19:35:13 +02005045 s->last_change = now.tv_sec;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005046 s->next_state = SRV_ST_STARTING;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02005047 if (s->slowstart > 0) {
5048 if (s->warmup)
5049 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
5050 }
Emeric Brun64cc49c2017-10-03 14:46:45 +02005051 else
5052 s->next_state = SRV_ST_RUNNING;
5053 }
5054
5055 }
5056
5057 tmptrash = alloc_trash_chunk();
5058 if (tmptrash) {
5059 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5060 chunk_printf(tmptrash,
5061 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
5062 s->flags & SRV_F_BACKUP ? "Backup " : "",
5063 s->proxy->id, s->id,
5064 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5065 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5066 }
5067 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5068 chunk_printf(tmptrash,
5069 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
5070 s->flags & SRV_F_BACKUP ? "Backup " : "",
5071 s->proxy->id, s->id, s->hostname,
5072 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5073 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5074 }
5075 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5076 chunk_printf(tmptrash,
5077 "%sServer %s/%s is %s/%s (leaving maintenance)",
5078 s->flags & SRV_F_BACKUP ? "Backup " : "",
5079 s->proxy->id, s->id,
5080 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5081 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5082 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005083 ha_warning("%s.\n", tmptrash->area);
5084 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5085 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005086 free_trash_chunk(tmptrash);
5087 tmptrash = NULL;
5088 }
5089
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005090 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005091 /* now propagate the status change to any LB algorithms */
5092 if (px->lbprm.update_server_eweight)
5093 px->lbprm.update_server_eweight(s);
5094 else if (srv_willbe_usable(s)) {
5095 if (px->lbprm.set_server_status_up)
5096 px->lbprm.set_server_status_up(s);
5097 }
5098 else {
5099 if (px->lbprm.set_server_status_down)
5100 px->lbprm.set_server_status_down(s);
5101 }
5102
5103 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5104 set_backend_down(s->proxy);
Willy Tarreauf79c4cf2021-08-04 19:35:13 +02005105 else if (!prev_srv_count && (s->proxy->srv_bck || s->proxy->srv_act))
5106 s->proxy->last_change = now.tv_sec;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005107
Willy Tarreau6a78e612018-08-07 10:14:53 +02005108 /* If the server is set with "on-marked-up shutdown-backup-sessions",
5109 * and it's not a backup server and its effective weight is > 0,
5110 * then it can accept new connections, so we shut down all streams
5111 * on all backup servers.
5112 */
5113 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
5114 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
5115 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
5116
5117 /* check if we can handle some connections queued at the proxy. We
5118 * will take as many as we can handle.
5119 */
5120 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005121 }
5122 else if (s->next_admin & SRV_ADMF_MAINT) {
5123 /* remaining in maintenance mode, let's inform precisely about the
5124 * situation.
5125 */
5126 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5127 tmptrash = alloc_trash_chunk();
5128 if (tmptrash) {
5129 chunk_printf(tmptrash,
5130 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
5131 s->flags & SRV_F_BACKUP ? "Backup " : "",
5132 s->proxy->id, s->id);
5133
5134 if (s->track) /* normally it's mandatory here */
5135 chunk_appendf(tmptrash, " via %s/%s",
5136 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005137 ha_warning("%s.\n", tmptrash->area);
5138 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5139 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005140 free_trash_chunk(tmptrash);
5141 tmptrash = NULL;
5142 }
5143 }
5144 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5145 tmptrash = alloc_trash_chunk();
5146 if (tmptrash) {
5147 chunk_printf(tmptrash,
5148 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
5149 s->flags & SRV_F_BACKUP ? "Backup " : "",
5150 s->proxy->id, s->id, s->hostname);
5151
5152 if (s->track) /* normally it's mandatory here */
5153 chunk_appendf(tmptrash, " via %s/%s",
5154 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005155 ha_warning("%s.\n", tmptrash->area);
5156 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5157 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005158 free_trash_chunk(tmptrash);
5159 tmptrash = NULL;
5160 }
5161 }
5162 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5163 tmptrash = alloc_trash_chunk();
5164 if (tmptrash) {
5165 chunk_printf(tmptrash,
5166 "%sServer %s/%s remains in forced maintenance",
5167 s->flags & SRV_F_BACKUP ? "Backup " : "",
5168 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005169 ha_warning("%s.\n", tmptrash->area);
5170 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5171 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005172 free_trash_chunk(tmptrash);
5173 tmptrash = NULL;
5174 }
5175 }
5176 /* don't report anything when leaving drain mode and remaining in maintenance */
5177
5178 s->cur_admin = s->next_admin;
5179 }
5180
5181 if (!(s->next_admin & SRV_ADMF_MAINT)) {
5182 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
5183 /* drain state is applied only if not yet in maint */
5184
5185 s->last_change = now.tv_sec;
5186 if (px->lbprm.set_server_status_down)
5187 px->lbprm.set_server_status_down(s);
5188
5189 /* we might have streams queued on this server and waiting for
5190 * a connection. Those which are redispatchable will be queued
5191 * to another server or to the proxy itself.
5192 */
5193 xferred = pendconn_redistribute(s);
5194
5195 tmptrash = alloc_trash_chunk();
5196 if (tmptrash) {
5197 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
5198 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5199 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5200
5201 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
5202
5203 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005204 ha_warning("%s.\n", tmptrash->area);
5205 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5206 tmptrash->area);
5207 send_email_alert(s, LOG_NOTICE, "%s",
5208 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005209 }
5210 free_trash_chunk(tmptrash);
5211 tmptrash = NULL;
5212 }
5213
5214 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5215 set_backend_down(s->proxy);
5216 }
5217 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
5218 /* OK completely leaving drain mode */
5219 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
5220 if (s->proxy->last_change < now.tv_sec) // ignore negative times
5221 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
5222 s->proxy->last_change = now.tv_sec;
5223 }
5224
5225 if (s->last_change < now.tv_sec) // ignore negative times
5226 s->down_time += now.tv_sec - s->last_change;
5227 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005228 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005229
5230 tmptrash = alloc_trash_chunk();
5231 if (tmptrash) {
5232 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5233 chunk_printf(tmptrash,
5234 "%sServer %s/%s is %s (leaving forced drain)",
5235 s->flags & SRV_F_BACKUP ? "Backup " : "",
5236 s->proxy->id, s->id,
5237 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5238 }
5239 else {
5240 chunk_printf(tmptrash,
5241 "%sServer %s/%s is %s (leaving drain)",
5242 s->flags & SRV_F_BACKUP ? "Backup " : "",
5243 s->proxy->id, s->id,
5244 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5245 if (s->track) /* normally it's mandatory here */
5246 chunk_appendf(tmptrash, " via %s/%s",
5247 s->track->proxy->id, s->track->id);
5248 }
5249
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005250 ha_warning("%s.\n", tmptrash->area);
5251 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5252 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005253 free_trash_chunk(tmptrash);
5254 tmptrash = NULL;
5255 }
5256
5257 /* now propagate the status change to any LB algorithms */
5258 if (px->lbprm.update_server_eweight)
5259 px->lbprm.update_server_eweight(s);
5260 else if (srv_willbe_usable(s)) {
5261 if (px->lbprm.set_server_status_up)
5262 px->lbprm.set_server_status_up(s);
5263 }
5264 else {
5265 if (px->lbprm.set_server_status_down)
5266 px->lbprm.set_server_status_down(s);
5267 }
5268 }
5269 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
5270 /* remaining in drain mode after removing one of its flags */
5271
5272 tmptrash = alloc_trash_chunk();
5273 if (tmptrash) {
5274 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5275 chunk_printf(tmptrash,
5276 "%sServer %s/%s is leaving forced drain but remains in drain mode",
5277 s->flags & SRV_F_BACKUP ? "Backup " : "",
5278 s->proxy->id, s->id);
5279
5280 if (s->track) /* normally it's mandatory here */
5281 chunk_appendf(tmptrash, " via %s/%s",
5282 s->track->proxy->id, s->track->id);
5283 }
5284 else {
5285 chunk_printf(tmptrash,
5286 "%sServer %s/%s remains in forced drain mode",
5287 s->flags & SRV_F_BACKUP ? "Backup " : "",
5288 s->proxy->id, s->id);
5289 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005290 ha_warning("%s.\n", tmptrash->area);
5291 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5292 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005293 free_trash_chunk(tmptrash);
5294 tmptrash = NULL;
5295 }
5296
5297 /* commit new admin status */
5298
5299 s->cur_admin = s->next_admin;
5300 }
5301 }
5302
5303 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02005304 *s->adm_st_chg_cause = 0;
5305}
Emeric Brun64cc49c2017-10-03 14:46:45 +02005306
Willy Tarreau144f84a2021-03-02 16:09:26 +01005307struct task *srv_cleanup_toremove_conns(struct task *task, void *context, unsigned int state)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005308{
5309 struct connection *conn;
5310
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005311 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005312 struct connection *, toremove_list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02005313 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005314 }
5315
5316 return task;
5317}
5318
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005319/* Move toremove_nb connections from idle_tree to toremove_list, -1 means
Olivier Houchardff1d0922020-06-29 20:15:59 +02005320 * moving them all.
5321 * Returns the number of connections moved.
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005322 *
5323 * Must be called with idle_conns_lock held.
Olivier Houchardff1d0922020-06-29 20:15:59 +02005324 */
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005325static 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 +02005326{
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005327 struct eb_node *node, *next;
Amaury Denoyelle8990b012021-02-19 15:29:16 +01005328 struct conn_hash_node *hash_node;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005329 int i = 0;
5330
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005331 node = eb_first(idle_tree);
5332 while (node) {
5333 next = eb_next(node);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005334 if (toremove_nb != -1 && i >= toremove_nb)
5335 break;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005336
Amaury Denoyelle8990b012021-02-19 15:29:16 +01005337 hash_node = ebmb_entry(node, struct conn_hash_node, node);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005338 eb_delete(node);
Willy Tarreau2b718102021-04-21 07:32:39 +02005339 MT_LIST_APPEND(toremove_list, &hash_node->conn->toremove_list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005340 i++;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005341
5342 node = next;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005343 }
5344 return i;
5345}
William Dauchy6318d332020-05-02 21:52:36 +02005346/* cleanup connections for a given server
5347 * might be useful when going on forced maintenance or live changing ip/port
5348 */
William Dauchy707ad322020-05-04 13:52:40 +02005349static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02005350{
William Dauchy6318d332020-05-02 21:52:36 +02005351 int did_remove;
5352 int i;
William Dauchy6318d332020-05-02 21:52:36 +02005353
Amaury Denoyelle10d5c312021-01-06 14:28:51 +01005354 /* nothing to do if pool-max-conn is null */
5355 if (!srv->max_idle_conns)
5356 return;
5357
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005358 /* check all threads starting with ours */
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005359 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02005360 did_remove = 0;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005361 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005362 if (srv_migrate_conns_to_remove(&srv->per_thr[i].idle_conns, &idle_conns[i].toremove_conns, -1) > 0)
William Dauchy6318d332020-05-02 21:52:36 +02005363 did_remove = 1;
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005364 if (srv_migrate_conns_to_remove(&srv->per_thr[i].safe_conns, &idle_conns[i].toremove_conns, -1) > 0)
Olivier Houchardff1d0922020-06-29 20:15:59 +02005365 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005366 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
William Dauchy6318d332020-05-02 21:52:36 +02005367 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005368 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005369
5370 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5371 break;
William Dauchy6318d332020-05-02 21:52:36 +02005372 }
William Dauchy6318d332020-05-02 21:52:36 +02005373}
5374
Willy Tarreau144f84a2021-03-02 16:09:26 +01005375struct task *srv_cleanup_idle_conns(struct task *task, void *context, unsigned int state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005376{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005377 struct server *srv;
5378 struct eb32_node *eb;
5379 int i;
5380 unsigned int next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005381
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005382 next_wakeup = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005383 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
5384 while (1) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005385 int exceed_conns;
5386 int to_kill;
5387 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005388
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005389 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
5390 if (!eb) {
5391 /* we might have reached the end of the tree, typically because
5392 * <now_ms> is in the first half and we're first scanning the last
5393 * half. Let's loop back to the beginning of the tree now.
5394 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005395
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005396 eb = eb32_first(&idle_conn_srv);
5397 if (likely(!eb))
5398 break;
5399 }
5400 if (tick_is_lt(now_ms, eb->key)) {
5401 /* timer not expired yet, revisit it later */
5402 next_wakeup = eb->key;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005403 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005404 }
5405 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005406
5407 /* Calculate how many idle connections we want to kill :
5408 * we want to remove half the difference between the total
5409 * of established connections (used or idle) and the max
5410 * number of used connections.
5411 */
5412 curr_idle = srv->curr_idle_conns;
5413 if (curr_idle == 0)
5414 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005415 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005416 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005417
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005418 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns) / 2;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005419 if (srv->est_need_conns < srv->max_used_conns)
5420 srv->est_need_conns = srv->max_used_conns;
5421
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005422 srv->max_used_conns = srv->curr_used_conns;
5423
Willy Tarreau18ed7892020-07-02 19:05:30 +02005424 if (exceed_conns <= 0)
5425 goto remove;
5426
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005427 /* check all threads starting with ours */
5428 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005429 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005430 int j;
5431 int did_remove = 0;
5432
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005433 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
5434 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005435
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005436 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005437 j = srv_migrate_conns_to_remove(&srv->per_thr[i].idle_conns, &idle_conns[i].toremove_conns, max_conn);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005438 if (j > 0)
5439 did_remove = 1;
5440 if (max_conn - j > 0 &&
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005441 srv_migrate_conns_to_remove(&srv->per_thr[i].safe_conns, &idle_conns[i].toremove_conns, max_conn - j) > 0)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005442 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005443 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005444
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005445 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005446 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005447
5448 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5449 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005450 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005451remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005452 eb32_delete(&srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005453
5454 if (srv->curr_idle_conns) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005455 /* There are still more idle connections, add the
5456 * server back in the tree.
5457 */
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005458 srv->idle_node.key = tick_add(srv->pool_purge_delay, now_ms);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005459 eb32_insert(&idle_conn_srv, &srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005460 next_wakeup = tick_first(next_wakeup, srv->idle_node.key);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005461 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005462 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005463 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5464
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005465 task->expire = next_wakeup;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005466 return task;
5467}
Olivier Houchard88698d92019-04-16 19:07:22 +02005468
Amaury Denoyelle3109ccf2021-04-29 17:30:05 +02005469/* Close remaining idle connections. This functions is designed to be run on
5470 * process shutdown. This guarantees a proper socket shutdown to avoid
5471 * TIME_WAIT state. For a quick operation, only ctrl is closed, xprt stack is
5472 * bypassed.
5473 *
5474 * This function is not thread-safe so it must only be called via a global
5475 * deinit function.
5476 */
5477static void srv_close_idle_conns(struct server *srv)
5478{
5479 struct eb_root **cleaned_tree;
5480 int i;
5481
5482 for (i = 0; i < global.nbthread; ++i) {
5483 struct eb_root *conn_trees[] = {
5484 &srv->per_thr[i].idle_conns,
5485 &srv->per_thr[i].safe_conns,
5486 &srv->per_thr[i].avail_conns,
5487 NULL
5488 };
5489
5490 for (cleaned_tree = conn_trees; *cleaned_tree; ++cleaned_tree) {
5491 while (!eb_is_empty(*cleaned_tree)) {
5492 struct ebmb_node *node = ebmb_first(*cleaned_tree);
5493 struct conn_hash_node *conn_hash_node = ebmb_entry(node, struct conn_hash_node, node);
5494 struct connection *conn = conn_hash_node->conn;
5495
5496 if (conn->ctrl->ctrl_close)
5497 conn->ctrl->ctrl_close(conn);
5498 ebmb_delete(node);
5499 }
5500 }
5501 }
5502}
5503
5504REGISTER_SERVER_DEINIT(srv_close_idle_conns);
5505
Willy Tarreau76cc6992020-07-01 18:49:24 +02005506/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
5507static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01005508 const struct proxy *defpx, const char *file, int line,
Willy Tarreau76cc6992020-07-01 18:49:24 +02005509 char **err)
5510{
5511 if (too_many_args(1, args, err, NULL))
5512 return -1;
5513
5514 if (strcmp(args[1], "on") == 0)
5515 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
5516 else if (strcmp(args[1], "off") == 0)
5517 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
5518 else {
5519 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
5520 return -1;
5521 }
5522 return 0;
5523}
5524
Olivier Houchard88698d92019-04-16 19:07:22 +02005525/* config parser for global "tune.pool-{low,high}-fd-ratio" */
5526static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01005527 const struct proxy *defpx, const char *file, int line,
Olivier Houchard88698d92019-04-16 19:07:22 +02005528 char **err)
5529{
5530 int arg = -1;
5531
5532 if (too_many_args(1, args, err, NULL))
5533 return -1;
5534
5535 if (*(args[1]) != 0)
5536 arg = atoi(args[1]);
5537
5538 if (arg < 0 || arg > 100) {
5539 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
5540 return -1;
5541 }
5542
5543 if (args[0][10] == 'h')
5544 global.tune.pool_high_ratio = arg;
5545 else
5546 global.tune.pool_low_ratio = arg;
5547 return 0;
5548}
5549
5550/* config keyword parsers */
5551static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02005552 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02005553 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
5554 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
5555 { 0, NULL, NULL }
5556}};
5557
5558INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
5559
Baptiste Assmanna68ca962015-04-14 01:15:08 +02005560/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02005561 * Local variables:
5562 * c-indent-level: 8
5563 * c-basic-offset: 8
5564 * End:
5565 */