blob: df67e1d9b868853bd0b47018575974b49fd3d93b [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
Amaury Denoyelle8e99b842021-10-18 14:39:57 +0200200/* Returns true if it's possible to reuse an idle connection from server <srv>
201 * for a websocket stream. This is the case if server is configured to use the
202 * same protocol for both HTTP and websocket streams. This depends on the value
203 * of "proto", "alpn" and "ws" keywords.
204 */
205int srv_check_reuse_ws(struct server *srv)
206{
Amaury Denoyelleea489aa2021-11-25 10:20:19 +0100207#if defined(USE_OPENSSL) && defined(TLSEXT_TYPE_application_layer_protocol_negotiation)
208 if (!srv->mux_proto && srv->use_ssl && srv->ssl_ctx.alpn_str) {
209 /* ALPN selection.
210 * Based on the assumption that only "h2" and "http/1.1" token
211 * are used on server ALPN.
212 */
213 const struct ist alpn = ist2(srv->ssl_ctx.alpn_str,
214 srv->ssl_ctx.alpn_len);
215
216 switch (srv->ws) {
217 case SRV_WS_AUTO:
218 /* for auto mode, consider reuse as possible if the
219 * server uses a single protocol ALPN
220 */
221 if (!istchr(alpn, ','))
222 return 1;
223 break;
224
225 case SRV_WS_H2:
226 return isteq(alpn, ist("\x02h2"));
227
228 case SRV_WS_H1:
229 return isteq(alpn, ist("\x08http/1.1"));
230 }
231 }
232 else {
233#endif /* defined(OPENSSL) && defined(TLSEXT_TYPE_application_layer_protocol_negotiation) */
Amaury Denoyelle8e99b842021-10-18 14:39:57 +0200234 /* explicit srv.mux_proto or no ALPN : srv.mux_proto is used
235 * for mux selection.
236 */
237 const struct ist srv_mux = srv->mux_proto ?
238 srv->mux_proto->token : IST_NULL;
239
240 switch (srv->ws) {
241 /* "auto" means use the same protocol : reuse is possible. */
242 case SRV_WS_AUTO:
243 return 1;
244
245 /* "h2" means use h2 for websocket : reuse is possible if
246 * server mux is h2.
247 */
248 case SRV_WS_H2:
249 if (srv->mux_proto && isteq(srv_mux, ist("h2")))
250 return 1;
251 break;
252
253 /* "h1" means use h1 for websocket : reuse is possible if
254 * server mux is h1.
255 */
256 case SRV_WS_H1:
257 if (!srv->mux_proto || isteq(srv_mux, ist("h1")))
258 return 1;
259 break;
260 }
Amaury Denoyelleea489aa2021-11-25 10:20:19 +0100261#if defined(USE_OPENSSL) && defined(TLSEXT_TYPE_application_layer_protocol_negotiation)
Amaury Denoyelle8e99b842021-10-18 14:39:57 +0200262 }
Amaury Denoyelleea489aa2021-11-25 10:20:19 +0100263#endif /* defined(OPENSSL) && defined(TLSEXT_TYPE_application_layer_protocol_negotiation) */
Amaury Denoyelle8e99b842021-10-18 14:39:57 +0200264
265 return 0;
266}
267
268/* Return the proto to used for a websocket stream on <srv> without ALPN. NULL
269 * is a valid value indicating to use the fallback mux.
270 */
271const struct mux_ops *srv_get_ws_proto(struct server *srv)
272{
273 const struct mux_proto_list *mux = NULL;
274
275 switch (srv->ws) {
276 case SRV_WS_AUTO:
277 mux = srv->mux_proto;
278 break;
279
280 case SRV_WS_H1:
281 mux = get_mux_proto(ist("h1"));
282 break;
283
284 case SRV_WS_H2:
285 mux = get_mux_proto(ist("h2"));
286 break;
287 }
288
289 return mux ? mux->mux : NULL;
290}
291
Willy Tarreau21faa912012-10-10 08:27:36 +0200292/*
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +0200293 * Must be called with the server lock held. The server is first removed from
294 * the proxy tree if it was already attached. If <reattach> is true, the server
295 * will then be attached in the proxy tree. The proxy lock is held to
296 * manipulate the tree.
Thayne McCombs92149f92020-11-20 01:28:26 -0700297 */
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +0200298static void srv_set_addr_desc(struct server *s, int reattach)
Thayne McCombs92149f92020-11-20 01:28:26 -0700299{
300 struct proxy *p = s->proxy;
301 char *key;
302
303 key = sa2str(&s->addr, s->svc_port, s->flags & SRV_F_MAPPORTS);
304
305 if (s->addr_node.key) {
Thayne McCombs24da7e12021-01-05 23:10:09 -0700306 if (key && strcmp(key, s->addr_node.key) == 0) {
Thayne McCombs92149f92020-11-20 01:28:26 -0700307 free(key);
308 return;
309 }
310
311 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
312 ebpt_delete(&s->addr_node);
313 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
314
315 free(s->addr_node.key);
316 }
317
318 s->addr_node.key = key;
319
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +0200320 if (reattach) {
321 if (s->addr_node.key) {
322 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
323 ebis_insert(&p->used_server_addr, &s->addr_node);
324 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
325 }
Thayne McCombs24da7e12021-01-05 23:10:09 -0700326 }
Thayne McCombs92149f92020-11-20 01:28:26 -0700327}
328
329/*
Willy Tarreau21faa912012-10-10 08:27:36 +0200330 * Registers the server keyword list <kwl> as a list of valid keywords for next
331 * parsing sessions.
332 */
333void srv_register_keywords(struct srv_kw_list *kwl)
334{
Willy Tarreau2b718102021-04-21 07:32:39 +0200335 LIST_APPEND(&srv_keywords.list, &kwl->list);
Willy Tarreau21faa912012-10-10 08:27:36 +0200336}
337
338/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
339 * keyword is found with a NULL ->parse() function, then an attempt is made to
340 * find one with a valid ->parse() function. This way it is possible to declare
341 * platform-dependant, known keywords as NULL, then only declare them as valid
342 * if some options are met. Note that if the requested keyword contains an
343 * opening parenthesis, everything from this point is ignored.
344 */
345struct srv_kw *srv_find_kw(const char *kw)
346{
347 int index;
348 const char *kwend;
349 struct srv_kw_list *kwl;
350 struct srv_kw *ret = NULL;
351
352 kwend = strchr(kw, '(');
353 if (!kwend)
354 kwend = kw + strlen(kw);
355
356 list_for_each_entry(kwl, &srv_keywords.list, list) {
357 for (index = 0; kwl->kw[index].kw != NULL; index++) {
358 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
359 kwl->kw[index].kw[kwend-kw] == 0) {
360 if (kwl->kw[index].parse)
361 return &kwl->kw[index]; /* found it !*/
362 else
363 ret = &kwl->kw[index]; /* may be OK */
364 }
365 }
366 }
367 return ret;
368}
369
370/* Dumps all registered "server" keywords to the <out> string pointer. The
371 * unsupported keywords are only dumped if their supported form was not
372 * found.
373 */
374void srv_dump_kws(char **out)
375{
376 struct srv_kw_list *kwl;
377 int index;
378
Christopher Faulet784063e2020-05-18 12:14:18 +0200379 if (!out)
380 return;
381
Willy Tarreau21faa912012-10-10 08:27:36 +0200382 *out = NULL;
383 list_for_each_entry(kwl, &srv_keywords.list, list) {
384 for (index = 0; kwl->kw[index].kw != NULL; index++) {
385 if (kwl->kw[index].parse ||
386 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
387 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
388 kwl->scope,
389 kwl->kw[index].kw,
390 kwl->kw[index].skip ? " <arg>" : "",
391 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
392 kwl->kw[index].parse ? "" : " (not supported)");
393 }
394 }
395 }
Willy Tarreau49c2b452021-03-12 09:58:04 +0100396}
397
398/* Try to find in srv_keyword the word that looks closest to <word> by counting
399 * transitions between letters, digits and other characters. Will return the
400 * best matching word if found, otherwise NULL. An optional array of extra
401 * words to compare may be passed in <extra>, but it must then be terminated
402 * by a NULL entry. If unused it may be NULL.
403 */
404static const char *srv_find_best_kw(const char *word)
405{
406 uint8_t word_sig[1024];
407 uint8_t list_sig[1024];
408 const struct srv_kw_list *kwl;
409 const char *best_ptr = NULL;
410 int dist, best_dist = INT_MAX;
411 const char **extra;
412 int index;
413
414 make_word_fingerprint(word_sig, word);
415 list_for_each_entry(kwl, &srv_keywords.list, list) {
416 for (index = 0; kwl->kw[index].kw != NULL; index++) {
417 make_word_fingerprint(list_sig, kwl->kw[index].kw);
418 dist = word_fingerprint_distance(word_sig, list_sig);
419 if (dist < best_dist) {
420 best_dist = dist;
421 best_ptr = kwl->kw[index].kw;
422 }
423 }
424 }
425
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100426 for (extra = extra_kw_list; *extra; extra++) {
Willy Tarreau49c2b452021-03-12 09:58:04 +0100427 make_word_fingerprint(list_sig, *extra);
428 dist = word_fingerprint_distance(word_sig, list_sig);
429 if (dist < best_dist) {
430 best_dist = dist;
431 best_ptr = *extra;
432 }
Willy Tarreau49c2b452021-03-12 09:58:04 +0100433 }
434
435 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
436 best_ptr = NULL;
437
438 return best_ptr;
Willy Tarreau21faa912012-10-10 08:27:36 +0200439}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100440
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100441/* Parse the "backup" server keyword */
442static int srv_parse_backup(char **args, int *cur_arg,
443 struct proxy *curproxy, struct server *newsrv, char **err)
444{
445 newsrv->flags |= SRV_F_BACKUP;
446 return 0;
447}
448
Alexander Liu2a54bb72019-05-22 19:44:48 +0800449
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100450/* Parse the "cookie" server keyword */
451static int srv_parse_cookie(char **args, int *cur_arg,
452 struct proxy *curproxy, struct server *newsrv, char **err)
453{
454 char *arg;
455
456 arg = args[*cur_arg + 1];
457 if (!*arg) {
458 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
459 return ERR_ALERT | ERR_FATAL;
460 }
461
462 free(newsrv->cookie);
463 newsrv->cookie = strdup(arg);
464 newsrv->cklen = strlen(arg);
465 newsrv->flags |= SRV_F_COOKIESET;
466 return 0;
467}
468
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100469/* Parse the "disabled" server keyword */
470static int srv_parse_disabled(char **args, int *cur_arg,
471 struct proxy *curproxy, struct server *newsrv, char **err)
472{
Emeric Brun52a91d32017-08-31 14:41:55 +0200473 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
474 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100475 newsrv->check.state |= CHK_ST_PAUSED;
476 newsrv->check.health = 0;
477 return 0;
478}
479
480/* Parse the "enabled" server keyword */
481static int srv_parse_enabled(char **args, int *cur_arg,
482 struct proxy *curproxy, struct server *newsrv, char **err)
483{
Emeric Brun52a91d32017-08-31 14:41:55 +0200484 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
485 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100486 newsrv->check.state &= ~CHK_ST_PAUSED;
487 newsrv->check.health = newsrv->check.rise;
488 return 0;
489}
490
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100491/* Parse the "error-limit" server keyword */
492static int srv_parse_error_limit(char **args, int *cur_arg,
493 struct proxy *curproxy, struct server *newsrv, char **err)
494{
495 if (!*args[*cur_arg + 1]) {
496 memprintf(err, "'%s' expects an integer argument.",
497 args[*cur_arg]);
498 return ERR_ALERT | ERR_FATAL;
499 }
500
501 newsrv->consecutive_errors_limit = atoi(args[*cur_arg + 1]);
502
503 if (newsrv->consecutive_errors_limit <= 0) {
504 memprintf(err, "%s has to be > 0.",
505 args[*cur_arg]);
506 return ERR_ALERT | ERR_FATAL;
507 }
508
509 return 0;
510}
511
Amaury Denoyelle69352ec2021-10-18 14:40:29 +0200512/* Parse the "ws" keyword */
513static int srv_parse_ws(char **args, int *cur_arg,
514 struct proxy *curproxy, struct server *newsrv, char **err)
515{
516 if (!args[*cur_arg + 1]) {
517 memprintf(err, "'%s' expects 'auto', 'h1' or 'h2' value", args[*cur_arg]);
518 return ERR_ALERT | ERR_FATAL;
519 }
520
521 if (strcmp(args[*cur_arg + 1], "h1") == 0) {
522 newsrv->ws = SRV_WS_H1;
523 }
524 else if (strcmp(args[*cur_arg + 1], "h2") == 0) {
525 newsrv->ws = SRV_WS_H2;
526 }
527 else if (strcmp(args[*cur_arg + 1], "auto") == 0) {
528 newsrv->ws = SRV_WS_AUTO;
529 }
530 else {
531 memprintf(err, "'%s' has to be 'auto', 'h1' or 'h2'", args[*cur_arg]);
532 return ERR_ALERT | ERR_FATAL;
533 }
534
535
536 return 0;
537}
538
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100539/* Parse the "init-addr" server keyword */
540static int srv_parse_init_addr(char **args, int *cur_arg,
541 struct proxy *curproxy, struct server *newsrv, char **err)
542{
543 char *p, *end;
544 int done;
545 struct sockaddr_storage sa;
546
547 newsrv->init_addr_methods = 0;
548 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
549
550 for (p = args[*cur_arg + 1]; *p; p = end) {
551 /* cut on next comma */
552 for (end = p; *end && *end != ','; end++);
553 if (*end)
554 *(end++) = 0;
555
556 memset(&sa, 0, sizeof(sa));
557 if (strcmp(p, "libc") == 0) {
558 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
559 }
560 else if (strcmp(p, "last") == 0) {
561 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
562 }
563 else if (strcmp(p, "none") == 0) {
564 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
565 }
566 else if (str2ip2(p, &sa, 0)) {
567 if (is_addr(&newsrv->init_addr)) {
568 memprintf(err, "'%s' : initial address already specified, cannot add '%s'.",
569 args[*cur_arg], p);
570 return ERR_ALERT | ERR_FATAL;
571 }
572 newsrv->init_addr = sa;
573 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
574 }
575 else {
576 memprintf(err, "'%s' : unknown init-addr method '%s', supported methods are 'libc', 'last', 'none'.",
577 args[*cur_arg], p);
578 return ERR_ALERT | ERR_FATAL;
579 }
580 if (!done) {
581 memprintf(err, "'%s' : too many init-addr methods when trying to add '%s'",
582 args[*cur_arg], p);
583 return ERR_ALERT | ERR_FATAL;
584 }
585 }
586
587 return 0;
588}
589
590/* Parse the "log-proto" server keyword */
591static int srv_parse_log_proto(char **args, int *cur_arg,
592 struct proxy *curproxy, struct server *newsrv, char **err)
593{
594 if (strcmp(args[*cur_arg + 1], "legacy") == 0)
595 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
596 else if (strcmp(args[*cur_arg + 1], "octet-count") == 0)
597 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
598 else {
599 memprintf(err, "'%s' expects one of 'legacy' or 'octet-count' but got '%s'",
600 args[*cur_arg], args[*cur_arg + 1]);
601 return ERR_ALERT | ERR_FATAL;
602 }
603
604 return 0;
605}
606
607/* Parse the "maxconn" server keyword */
608static int srv_parse_maxconn(char **args, int *cur_arg,
609 struct proxy *curproxy, struct server *newsrv, char **err)
610{
611 newsrv->maxconn = atol(args[*cur_arg + 1]);
612 return 0;
613}
614
615/* Parse the "maxqueue" server keyword */
616static int srv_parse_maxqueue(char **args, int *cur_arg,
617 struct proxy *curproxy, struct server *newsrv, char **err)
618{
619 newsrv->maxqueue = atol(args[*cur_arg + 1]);
620 return 0;
621}
622
623/* Parse the "minconn" server keyword */
624static int srv_parse_minconn(char **args, int *cur_arg,
625 struct proxy *curproxy, struct server *newsrv, char **err)
626{
627 newsrv->minconn = atol(args[*cur_arg + 1]);
628 return 0;
629}
630
Willy Tarreau9c538e02019-01-23 10:21:49 +0100631static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
632{
633 char *arg;
634
635 arg = args[*cur_arg + 1];
636 if (!*arg) {
637 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
638 return ERR_ALERT | ERR_FATAL;
639 }
640 newsrv->max_reuse = atoi(arg);
641
642 return 0;
643}
644
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100645static 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 +0100646{
647 const char *res;
648 char *arg;
649 unsigned int time;
650
651 arg = args[*cur_arg + 1];
652 if (!*arg) {
653 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
654 return ERR_ALERT | ERR_FATAL;
655 }
656 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200657 if (res == PARSE_TIME_OVER) {
658 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
659 args[*cur_arg+1], args[*cur_arg]);
660 return ERR_ALERT | ERR_FATAL;
661 }
662 else if (res == PARSE_TIME_UNDER) {
663 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
664 args[*cur_arg+1], args[*cur_arg]);
665 return ERR_ALERT | ERR_FATAL;
666 }
667 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100668 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
669 *res, args[*cur_arg]);
670 return ERR_ALERT | ERR_FATAL;
671 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100672 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100673
674 return 0;
675}
676
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200677static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
678{
679 char *arg;
680
681 arg = args[*cur_arg + 1];
682 if (!*arg) {
683 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
684 return ERR_ALERT | ERR_FATAL;
685 }
686
687 newsrv->low_idle_conns = atoi(arg);
688 return 0;
689}
690
Olivier Houchard006e3102018-12-10 18:30:32 +0100691static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
692{
693 char *arg;
694
695 arg = args[*cur_arg + 1];
696 if (!*arg) {
697 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
698 return ERR_ALERT | ERR_FATAL;
699 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100700
Olivier Houchard006e3102018-12-10 18:30:32 +0100701 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100702 if ((int)newsrv->max_idle_conns < -1) {
703 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
704 return ERR_ALERT | ERR_FATAL;
705 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100706
707 return 0;
708}
709
Willy Tarreaudff55432012-10-10 17:51:05 +0200710/* parse the "id" server keyword */
711static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
712{
713 struct eb32_node *node;
714
715 if (!*args[*cur_arg + 1]) {
716 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
717 return ERR_ALERT | ERR_FATAL;
718 }
719
720 newsrv->puid = atol(args[*cur_arg + 1]);
721 newsrv->conf.id.key = newsrv->puid;
722
723 if (newsrv->puid <= 0) {
724 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
725 return ERR_ALERT | ERR_FATAL;
726 }
727
728 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
729 if (node) {
730 struct server *target = container_of(node, struct server, conf.id);
731 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
732 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
733 target->id);
734 return ERR_ALERT | ERR_FATAL;
735 }
736
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200737 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200738 return 0;
739}
740
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100741/* Parse the "namespace" server keyword */
742static int srv_parse_namespace(char **args, int *cur_arg,
743 struct proxy *curproxy, struct server *newsrv, char **err)
744{
Willy Tarreaue5733232019-05-22 19:24:06 +0200745#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100746 char *arg;
747
748 arg = args[*cur_arg + 1];
749 if (!*arg) {
750 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
751 return ERR_ALERT | ERR_FATAL;
752 }
753
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100754 if (strcmp(arg, "*") == 0) {
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100755 /* Use the namespace associated with the connection (if present). */
756 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
757 return 0;
758 }
759
760 /*
761 * As this parser may be called several times for the same 'default-server'
762 * object, or for a new 'server' instance deriving from a 'default-server'
763 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
764 */
765 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
766
767 newsrv->netns = netns_store_lookup(arg, strlen(arg));
768 if (!newsrv->netns)
769 newsrv->netns = netns_store_insert(arg);
770
771 if (!newsrv->netns) {
772 memprintf(err, "Cannot open namespace '%s'", arg);
773 return ERR_ALERT | ERR_FATAL;
774 }
775
776 return 0;
777#else
778 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
779 return ERR_ALERT | ERR_FATAL;
780#endif
781}
782
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100783/* Parse the "no-backup" server keyword */
784static int srv_parse_no_backup(char **args, int *cur_arg,
785 struct proxy *curproxy, struct server *newsrv, char **err)
786{
787 newsrv->flags &= ~SRV_F_BACKUP;
788 return 0;
789}
790
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100791
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100792/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200793static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100794{
795 srv->pp_opts &= ~flags;
796 return 0;
797}
798
799/* Parse the "no-send-proxy" server keyword */
800static int srv_parse_no_send_proxy(char **args, int *cur_arg,
801 struct proxy *curproxy, struct server *newsrv, char **err)
802{
803 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
804}
805
806/* Parse the "no-send-proxy-v2" server keyword */
807static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
808 struct proxy *curproxy, struct server *newsrv, char **err)
809{
810 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
811}
812
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200813/* Parse the "no-tfo" server keyword */
814static int srv_parse_no_tfo(char **args, int *cur_arg,
815 struct proxy *curproxy, struct server *newsrv, char **err)
816{
817 newsrv->flags &= ~SRV_F_FASTOPEN;
818 return 0;
819}
820
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100821/* Parse the "non-stick" server keyword */
822static int srv_parse_non_stick(char **args, int *cur_arg,
823 struct proxy *curproxy, struct server *newsrv, char **err)
824{
825 newsrv->flags |= SRV_F_NON_STICK;
826 return 0;
827}
828
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100829/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200830static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100831{
832 srv->pp_opts |= flags;
833 return 0;
834}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200835/* parse the "proto" server keyword */
836static int srv_parse_proto(char **args, int *cur_arg,
837 struct proxy *px, struct server *newsrv, char **err)
838{
839 struct ist proto;
840
841 if (!*args[*cur_arg + 1]) {
842 memprintf(err, "'%s' : missing value", args[*cur_arg]);
843 return ERR_ALERT | ERR_FATAL;
844 }
Tim Duesterhusdcf753a2021-03-04 17:31:47 +0100845 proto = ist(args[*cur_arg + 1]);
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200846 newsrv->mux_proto = get_mux_proto(proto);
847 if (!newsrv->mux_proto) {
848 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
849 return ERR_ALERT | ERR_FATAL;
850 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200851 return 0;
852}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100853
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100854/* parse the "proxy-v2-options" */
855static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
856 struct proxy *px, struct server *newsrv, char **err)
857{
858 char *p, *n;
859 for (p = args[*cur_arg+1]; p; p = n) {
860 n = strchr(p, ',');
861 if (n)
862 *n++ = '\0';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100863 if (strcmp(p, "ssl") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100864 newsrv->pp_opts |= SRV_PP_V2_SSL;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100865 } else if (strcmp(p, "cert-cn") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100866 newsrv->pp_opts |= SRV_PP_V2_SSL;
867 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100868 } else if (strcmp(p, "cert-key") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100869 newsrv->pp_opts |= SRV_PP_V2_SSL;
870 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100871 } else if (strcmp(p, "cert-sig") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100872 newsrv->pp_opts |= SRV_PP_V2_SSL;
873 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100874 } else if (strcmp(p, "ssl-cipher") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100875 newsrv->pp_opts |= SRV_PP_V2_SSL;
876 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100877 } else if (strcmp(p, "authority") == 0) {
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100878 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100879 } else if (strcmp(p, "crc32c") == 0) {
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100880 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100881 } else if (strcmp(p, "unique-id") == 0) {
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100882 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100883 } else
884 goto fail;
885 }
886 return 0;
887 fail:
888 if (err)
889 memprintf(err, "'%s' : proxy v2 option not implemented", p);
890 return ERR_ALERT | ERR_FATAL;
891}
892
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100893/* Parse the "observe" server keyword */
894static int srv_parse_observe(char **args, int *cur_arg,
895 struct proxy *curproxy, struct server *newsrv, char **err)
896{
897 char *arg;
898
899 arg = args[*cur_arg + 1];
900 if (!*arg) {
901 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
902 return ERR_ALERT | ERR_FATAL;
903 }
904
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100905 if (strcmp(arg, "none") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100906 newsrv->observe = HANA_OBS_NONE;
907 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100908 else if (strcmp(arg, "layer4") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100909 newsrv->observe = HANA_OBS_LAYER4;
910 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100911 else if (strcmp(arg, "layer7") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100912 if (curproxy->mode != PR_MODE_HTTP) {
913 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
914 return ERR_ALERT;
915 }
916 newsrv->observe = HANA_OBS_LAYER7;
917 }
918 else {
919 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
920 "but got '%s'\n", args[*cur_arg], arg);
921 return ERR_ALERT | ERR_FATAL;
922 }
923
924 return 0;
925}
926
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100927/* Parse the "on-error" server keyword */
928static int srv_parse_on_error(char **args, int *cur_arg,
929 struct proxy *curproxy, struct server *newsrv, char **err)
930{
931 if (strcmp(args[*cur_arg + 1], "fastinter") == 0)
932 newsrv->onerror = HANA_ONERR_FASTINTER;
933 else if (strcmp(args[*cur_arg + 1], "fail-check") == 0)
934 newsrv->onerror = HANA_ONERR_FAILCHK;
935 else if (strcmp(args[*cur_arg + 1], "sudden-death") == 0)
936 newsrv->onerror = HANA_ONERR_SUDDTH;
937 else if (strcmp(args[*cur_arg + 1], "mark-down") == 0)
938 newsrv->onerror = HANA_ONERR_MARKDWN;
939 else {
940 memprintf(err, "'%s' expects one of 'fastinter', "
941 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'",
942 args[*cur_arg], args[*cur_arg + 1]);
943 return ERR_ALERT | ERR_FATAL;
944 }
945
946 return 0;
947}
948
949/* Parse the "on-marked-down" server keyword */
950static int srv_parse_on_marked_down(char **args, int *cur_arg,
951 struct proxy *curproxy, struct server *newsrv, char **err)
952{
953 if (strcmp(args[*cur_arg + 1], "shutdown-sessions") == 0)
954 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
955 else {
956 memprintf(err, "'%s' expects 'shutdown-sessions' but got '%s'",
957 args[*cur_arg], args[*cur_arg + 1]);
958 return ERR_ALERT | ERR_FATAL;
959 }
960
961 return 0;
962}
963
964/* Parse the "on-marked-up" server keyword */
965static int srv_parse_on_marked_up(char **args, int *cur_arg,
966 struct proxy *curproxy, struct server *newsrv, char **err)
967{
968 if (strcmp(args[*cur_arg + 1], "shutdown-backup-sessions") == 0)
969 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
970 else {
971 memprintf(err, "'%s' expects 'shutdown-backup-sessions' but got '%s'",
972 args[*cur_arg], args[*cur_arg + 1]);
973 return ERR_ALERT | ERR_FATAL;
974 }
975
976 return 0;
977}
978
Frédéric Lécaille16186232017-03-14 16:42:49 +0100979/* Parse the "redir" server keyword */
980static int srv_parse_redir(char **args, int *cur_arg,
981 struct proxy *curproxy, struct server *newsrv, char **err)
982{
983 char *arg;
984
985 arg = args[*cur_arg + 1];
986 if (!*arg) {
987 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
988 return ERR_ALERT | ERR_FATAL;
989 }
990
991 free(newsrv->rdr_pfx);
992 newsrv->rdr_pfx = strdup(arg);
993 newsrv->rdr_len = strlen(arg);
994
995 return 0;
996}
997
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100998/* Parse the "resolvers" server keyword */
999static int srv_parse_resolvers(char **args, int *cur_arg,
1000 struct proxy *curproxy, struct server *newsrv, char **err)
1001{
1002 free(newsrv->resolvers_id);
1003 newsrv->resolvers_id = strdup(args[*cur_arg + 1]);
1004 return 0;
1005}
1006
1007/* Parse the "resolve-net" server keyword */
1008static int srv_parse_resolve_net(char **args, int *cur_arg,
1009 struct proxy *curproxy, struct server *newsrv, char **err)
1010{
1011 char *p, *e;
1012 unsigned char mask;
1013 struct resolv_options *opt;
1014
1015 if (!args[*cur_arg + 1] || args[*cur_arg + 1][0] == '\0') {
1016 memprintf(err, "'%s' expects a list of networks.",
1017 args[*cur_arg]);
1018 return ERR_ALERT | ERR_FATAL;
1019 }
1020
1021 opt = &newsrv->resolv_opts;
1022
1023 /* Split arguments by comma, and convert it from ipv4 or ipv6
1024 * string network in in_addr or in6_addr.
1025 */
1026 p = args[*cur_arg + 1];
1027 e = p;
1028 while (*p != '\0') {
1029 /* If no room available, return error. */
1030 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
1031 memprintf(err, "'%s' exceed %d networks.",
1032 args[*cur_arg], SRV_MAX_PREF_NET);
1033 return ERR_ALERT | ERR_FATAL;
1034 }
1035 /* look for end or comma. */
1036 while (*e != ',' && *e != '\0')
1037 e++;
1038 if (*e == ',') {
1039 *e = '\0';
1040 e++;
1041 }
1042 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
1043 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
1044 /* Try to convert input string from ipv4 or ipv6 network. */
1045 opt->pref_net[opt->pref_net_nb].family = AF_INET;
1046 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
1047 &mask)) {
1048 /* Try to convert input string from ipv6 network. */
1049 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
1050 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
1051 } else {
1052 /* All network conversions fail, return error. */
1053 memprintf(err, "'%s' invalid network '%s'.",
1054 args[*cur_arg], p);
1055 return ERR_ALERT | ERR_FATAL;
1056 }
1057 opt->pref_net_nb++;
1058 p = e;
1059 }
1060
1061 return 0;
1062}
1063
1064/* Parse the "resolve-opts" server keyword */
1065static int srv_parse_resolve_opts(char **args, int *cur_arg,
1066 struct proxy *curproxy, struct server *newsrv, char **err)
1067{
1068 char *p, *end;
1069
1070 for (p = args[*cur_arg + 1]; *p; p = end) {
1071 /* cut on next comma */
1072 for (end = p; *end && *end != ','; end++);
1073 if (*end)
1074 *(end++) = 0;
1075
1076 if (strcmp(p, "allow-dup-ip") == 0) {
1077 newsrv->resolv_opts.accept_duplicate_ip = 1;
1078 }
1079 else if (strcmp(p, "ignore-weight") == 0) {
1080 newsrv->resolv_opts.ignore_weight = 1;
1081 }
1082 else if (strcmp(p, "prevent-dup-ip") == 0) {
1083 newsrv->resolv_opts.accept_duplicate_ip = 0;
1084 }
1085 else {
1086 memprintf(err, "'%s' : unknown resolve-opts option '%s', supported methods are 'allow-dup-ip', 'ignore-weight', and 'prevent-dup-ip'.",
1087 args[*cur_arg], p);
1088 return ERR_ALERT | ERR_FATAL;
1089 }
1090 }
1091
1092 return 0;
1093}
1094
1095/* Parse the "resolve-prefer" server keyword */
1096static int srv_parse_resolve_prefer(char **args, int *cur_arg,
1097 struct proxy *curproxy, struct server *newsrv, char **err)
1098{
1099 if (strcmp(args[*cur_arg + 1], "ipv4") == 0)
1100 newsrv->resolv_opts.family_prio = AF_INET;
1101 else if (strcmp(args[*cur_arg + 1], "ipv6") == 0)
1102 newsrv->resolv_opts.family_prio = AF_INET6;
1103 else {
1104 memprintf(err, "'%s' expects either ipv4 or ipv6 as argument.",
1105 args[*cur_arg]);
1106 return ERR_ALERT | ERR_FATAL;
1107 }
1108
1109 return 0;
1110}
1111
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001112/* Parse the "send-proxy" server keyword */
1113static int srv_parse_send_proxy(char **args, int *cur_arg,
1114 struct proxy *curproxy, struct server *newsrv, char **err)
1115{
1116 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
1117}
1118
1119/* Parse the "send-proxy-v2" server keyword */
1120static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
1121 struct proxy *curproxy, struct server *newsrv, char **err)
1122{
1123 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
1124}
1125
Amaury Denoyelle587b71e2021-03-10 16:36:02 +01001126/* Parse the "slowstart" server keyword */
1127static int srv_parse_slowstart(char **args, int *cur_arg,
1128 struct proxy *curproxy, struct server *newsrv, char **err)
1129{
1130 /* slowstart is stored in seconds */
1131 unsigned int val;
1132 const char *time_err = parse_time_err(args[*cur_arg + 1], &val, TIME_UNIT_MS);
1133
1134 if (time_err == PARSE_TIME_OVER) {
1135 memprintf(err, "overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
1136 args[*cur_arg+1], args[*cur_arg], newsrv->id);
1137 return ERR_ALERT | ERR_FATAL;
1138 }
1139 else if (time_err == PARSE_TIME_UNDER) {
1140 memprintf(err, "underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
1141 args[*cur_arg+1], args[*cur_arg], newsrv->id);
1142 return ERR_ALERT | ERR_FATAL;
1143 }
1144 else if (time_err) {
1145 memprintf(err, "unexpected character '%c' in 'slowstart' argument of server %s.",
1146 *time_err, newsrv->id);
1147 return ERR_ALERT | ERR_FATAL;
1148 }
1149 newsrv->slowstart = (val + 999) / 1000;
1150
1151 return 0;
1152}
Frédéric Lécailledba97072017-03-17 15:33:50 +01001153
1154/* Parse the "source" server keyword */
1155static int srv_parse_source(char **args, int *cur_arg,
1156 struct proxy *curproxy, struct server *newsrv, char **err)
1157{
1158 char *errmsg;
1159 int port_low, port_high;
1160 struct sockaddr_storage *sk;
Frédéric Lécailledba97072017-03-17 15:33:50 +01001161
1162 errmsg = NULL;
1163
1164 if (!*args[*cur_arg + 1]) {
1165 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
1166 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
1167 goto err;
1168 }
1169
1170 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001171 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
1172 &errmsg, NULL, NULL,
1173 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 +01001174 if (!sk) {
1175 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
1176 goto err;
1177 }
1178
Frédéric Lécailledba97072017-03-17 15:33:50 +01001179 newsrv->conn_src.opts |= CO_SRC_BIND;
1180 newsrv->conn_src.source_addr = *sk;
1181
1182 if (port_low != port_high) {
1183 int i;
1184
Frédéric Lécailledba97072017-03-17 15:33:50 +01001185 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
Remi Tricot-Le Bretondc187912021-05-12 09:44:06 +02001186 if (!newsrv->conn_src.sport_range) {
1187 ha_alert("Server '%s': Out of memory (sport_range)\n", args[0]);
1188 goto err;
1189 }
Frédéric Lécailledba97072017-03-17 15:33:50 +01001190 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
1191 newsrv->conn_src.sport_range->ports[i] = port_low + i;
1192 }
1193
1194 *cur_arg += 2;
1195 while (*(args[*cur_arg])) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001196 if (strcmp(args[*cur_arg], "usesrc") == 0) { /* address to use outside */
Frédéric Lécailledba97072017-03-17 15:33:50 +01001197#if defined(CONFIG_HAP_TRANSPARENT)
1198 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001199 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
1200 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +01001201 goto err;
1202 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001203 if (strcmp(args[*cur_arg + 1], "client") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +01001204 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1205 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
1206 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001207 else if (strcmp(args[*cur_arg + 1], "clientip") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +01001208 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1209 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
1210 }
1211 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
1212 char *name, *end;
1213
1214 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +01001215 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001216 name++;
1217
1218 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +01001219 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +01001220 end++;
1221
1222 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1223 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
1224 free(newsrv->conn_src.bind_hdr_name);
1225 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
Remi Tricot-Le Bretondc187912021-05-12 09:44:06 +02001226 if (!newsrv->conn_src.bind_hdr_name) {
1227 ha_alert("Server '%s': Out of memory (bind_hdr_name)\n", args[0]);
1228 goto err;
1229 }
Frédéric Lécailledba97072017-03-17 15:33:50 +01001230 newsrv->conn_src.bind_hdr_len = end - name;
1231 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
1232 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
1233 newsrv->conn_src.bind_hdr_occ = -1;
1234
1235 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +01001236 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001237 end++;
1238 if (*end == ',') {
1239 end++;
1240 name = end;
1241 if (*end == '-')
1242 end++;
Willy Tarreau90807112020-02-25 08:16:33 +01001243 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001244 end++;
1245 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
1246 }
1247
1248 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001249 ha_alert("usesrc hdr_ip(name,num) does not support negative"
1250 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001251 goto err;
1252 }
1253 }
1254 else {
1255 struct sockaddr_storage *sk;
1256 int port1, port2;
1257
1258 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001259 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, NULL, NULL,
1260 &errmsg, NULL, NULL,
1261 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001262 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001263 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001264 goto err;
1265 }
1266
Frédéric Lécailledba97072017-03-17 15:33:50 +01001267 newsrv->conn_src.tproxy_addr = *sk;
1268 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
1269 }
1270 global.last_checks |= LSTCHK_NETADM;
1271 *cur_arg += 2;
1272 continue;
1273#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001274 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 +01001275 goto err;
1276#endif /* defined(CONFIG_HAP_TRANSPARENT) */
1277 } /* "usesrc" */
1278
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001279 if (strcmp(args[*cur_arg], "interface") == 0) { /* specifically bind to this interface */
Frédéric Lécailledba97072017-03-17 15:33:50 +01001280#ifdef SO_BINDTODEVICE
1281 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001282 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001283 goto err;
1284 }
1285 free(newsrv->conn_src.iface_name);
1286 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
1287 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
1288 global.last_checks |= LSTCHK_NETADM;
1289#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001290 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001291 goto err;
1292#endif
1293 *cur_arg += 2;
1294 continue;
1295 }
1296 /* this keyword in not an option of "source" */
1297 break;
1298 } /* while */
1299
1300 return 0;
1301
1302 err:
1303 free(errmsg);
1304 return ERR_ALERT | ERR_FATAL;
1305}
1306
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001307/* Parse the "stick" server keyword */
1308static int srv_parse_stick(char **args, int *cur_arg,
1309 struct proxy *curproxy, struct server *newsrv, char **err)
1310{
1311 newsrv->flags &= ~SRV_F_NON_STICK;
1312 return 0;
1313}
1314
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001315/* Parse the "track" server keyword */
1316static int srv_parse_track(char **args, int *cur_arg,
1317 struct proxy *curproxy, struct server *newsrv, char **err)
1318{
1319 char *arg;
1320
1321 arg = args[*cur_arg + 1];
1322 if (!*arg) {
1323 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
1324 return ERR_ALERT | ERR_FATAL;
1325 }
1326
1327 free(newsrv->trackit);
1328 newsrv->trackit = strdup(arg);
1329
1330 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001331}
1332
1333/* Parse the "socks4" server keyword */
1334static int srv_parse_socks4(char **args, int *cur_arg,
1335 struct proxy *curproxy, struct server *newsrv, char **err)
1336{
1337 char *errmsg;
1338 int port_low, port_high;
1339 struct sockaddr_storage *sk;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001340
1341 errmsg = NULL;
1342
1343 if (!*args[*cur_arg + 1]) {
1344 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
1345 goto err;
1346 }
1347
1348 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001349 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
1350 &errmsg, NULL, NULL,
1351 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_CONNECT);
Alexander Liu2a54bb72019-05-22 19:44:48 +08001352 if (!sk) {
1353 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
1354 goto err;
1355 }
1356
Alexander Liu2a54bb72019-05-22 19:44:48 +08001357 newsrv->flags |= SRV_F_SOCKS4_PROXY;
1358 newsrv->socks4_addr = *sk;
1359
Alexander Liu2a54bb72019-05-22 19:44:48 +08001360 return 0;
1361
1362 err:
1363 free(errmsg);
1364 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001365}
1366
Frédéric Lécailledba97072017-03-17 15:33:50 +01001367
Willy Tarreau034c88c2017-01-23 23:36:45 +01001368/* parse the "tfo" server keyword */
1369static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1370{
1371 newsrv->flags |= SRV_F_FASTOPEN;
1372 return 0;
1373}
1374
Amaury Denoyelle587b71e2021-03-10 16:36:02 +01001375/* parse the "usesrc" server keyword */
1376static int srv_parse_usesrc(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1377{
1378 memprintf(err, "'%s' only allowed after a '%s' statement.",
1379 "usesrc", "source");
1380 return ERR_ALERT | ERR_FATAL;
1381}
1382
1383/* parse the "weight" server keyword */
1384static int srv_parse_weight(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1385{
1386 int w;
1387
1388 w = atol(args[*cur_arg + 1]);
1389 if (w < 0 || w > SRV_UWGHT_MAX) {
1390 memprintf(err, "weight of server %s is not within 0 and %d (%d).",
1391 newsrv->id, SRV_UWGHT_MAX, w);
1392 return ERR_ALERT | ERR_FATAL;
1393 }
1394 newsrv->uweight = newsrv->iweight = w;
1395
1396 return 0;
1397}
1398
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001399/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +02001400 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001401 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001402 *
1403 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001404 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001405void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001406{
Willy Tarreau751153e2021-02-17 13:33:24 +01001407 struct stream *stream;
1408 struct mt_list *elt1, elt2;
Willy Tarreaud4e78d82021-03-04 10:47:54 +01001409 int thr;
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001410
Willy Tarreaud4e78d82021-03-04 10:47:54 +01001411 for (thr = 0; thr < global.nbthread; thr++)
1412 mt_list_for_each_entry_safe(stream, &srv->per_thr[thr].streams, by_srv, elt1, elt2)
1413 if (stream->srv_conn == srv)
1414 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001415}
1416
1417/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +02001418 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001419 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001420 *
1421 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001422 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001423void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001424{
1425 struct server *srv;
1426
1427 for (srv = px->srv; srv != NULL; srv = srv->next)
1428 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +02001429 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001430}
1431
Willy Tarreaubda92272014-05-20 21:55:30 +02001432/* Appends some information to a message string related to a server going UP or
1433 * DOWN. If both <forced> and <reason> are null and the server tracks another
1434 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +02001435 * If <check> is non-null, an entire string describing the check result will be
1436 * appended after a comma and a space (eg: to report some information from the
1437 * check that changed the state). In the other case, the string will be built
1438 * using the check results stored into the struct server if present.
1439 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +02001440 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001441 *
1442 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001443 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001444void srv_append_status(struct buffer *msg, struct server *s,
1445 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001446{
Emeric Brun5a133512017-10-19 14:42:30 +02001447 short status = s->op_st_chg.status;
1448 short code = s->op_st_chg.code;
1449 long duration = s->op_st_chg.duration;
1450 char *desc = s->op_st_chg.reason;
1451
1452 if (check) {
1453 status = check->status;
1454 code = check->code;
1455 duration = check->duration;
1456 desc = check->desc;
1457 }
1458
1459 if (status != -1) {
1460 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
1461
1462 if (status >= HCHK_STATUS_L57DATA)
1463 chunk_appendf(msg, ", code: %d", code);
1464
1465 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001466 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +02001467
1468 chunk_appendf(msg, ", info: \"");
1469
1470 chunk_initlen(&src, desc, 0, strlen(desc));
1471 chunk_asciiencode(msg, &src, '"');
1472
1473 chunk_appendf(msg, "\"");
1474 }
1475
1476 if (duration >= 0)
1477 chunk_appendf(msg, ", check duration: %ldms", duration);
1478 }
1479 else if (desc && *desc) {
1480 chunk_appendf(msg, ", %s", desc);
1481 }
1482 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +02001483 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +02001484 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001485
1486 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +02001487 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001488 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
1489 " %d sessions active, %d requeued, %d remaining in queue",
1490 s->proxy->srv_act, s->proxy->srv_bck,
1491 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
1492 s->cur_sess, xferred, s->nbpend);
1493 else
1494 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
1495 " %d sessions requeued, %d total in queue",
1496 s->proxy->srv_act, s->proxy->srv_bck,
1497 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
1498 xferred, s->nbpend);
1499 }
1500}
1501
Emeric Brun5a133512017-10-19 14:42:30 +02001502/* Marks server <s> down, regardless of its checks' statuses. The server is
1503 * registered in a list to postpone the counting of the remaining servers on
1504 * the proxy and transfers queued streams whenever possible to other servers at
1505 * a sync point. Maintenance servers are ignored. It stores the <reason> if
1506 * non-null as the reason for going down or the available data from the check
1507 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001508 *
1509 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001510 */
Emeric Brun5a133512017-10-19 14:42:30 +02001511void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001512{
1513 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001514
Emeric Brun64cc49c2017-10-03 14:46:45 +02001515 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001516 return;
1517
Emeric Brun52a91d32017-08-31 14:41:55 +02001518 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001519 *s->op_st_chg.reason = 0;
1520 s->op_st_chg.status = -1;
1521 if (reason) {
1522 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1523 }
1524 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001525 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001526 s->op_st_chg.code = check->code;
1527 s->op_st_chg.status = check->status;
1528 s->op_st_chg.duration = check->duration;
1529 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001530
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001531 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001532 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001533
Emeric Brun9f0b4582017-10-23 14:39:51 +02001534 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001535 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001536 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001537 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001538 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001539}
1540
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001541/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001542 * in maintenance. The server is registered in a list to postpone the counting
1543 * of the remaining servers on the proxy and tries to grab requests from the
1544 * proxy at a sync point. Maintenance servers are ignored. It stores the
1545 * <reason> if non-null as the reason for going down or the available data
1546 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001547 *
1548 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001549 */
Emeric Brun5a133512017-10-19 14:42:30 +02001550void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001551{
1552 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001553
Emeric Brun64cc49c2017-10-03 14:46:45 +02001554 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001555 return;
1556
Emeric Brun52a91d32017-08-31 14:41:55 +02001557 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001558 return;
1559
Emeric Brun52a91d32017-08-31 14:41:55 +02001560 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001561 *s->op_st_chg.reason = 0;
1562 s->op_st_chg.status = -1;
1563 if (reason) {
1564 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1565 }
1566 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001567 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001568 s->op_st_chg.code = check->code;
1569 s->op_st_chg.status = check->status;
1570 s->op_st_chg.duration = check->duration;
1571 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001572
Emeric Brun64cc49c2017-10-03 14:46:45 +02001573 if (s->slowstart <= 0)
1574 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001575
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001576 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001577 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001578
Emeric Brun9f0b4582017-10-23 14:39:51 +02001579 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001580 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001581 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001582 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001583 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001584}
1585
Willy Tarreau8eb77842014-05-21 13:54:57 +02001586/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001587 * isn't in maintenance. The server is registered in a list to postpone the
1588 * counting of the remaining servers on the proxy and tries to grab requests
1589 * from the proxy. Maintenance servers are ignored. It stores the
1590 * <reason> if non-null as the reason for going down or the available data
1591 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001592 * up. Note that it makes use of the trash to build the log strings, so <reason>
1593 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001594 *
1595 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001596 */
Emeric Brun5a133512017-10-19 14:42:30 +02001597void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001598{
1599 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001600
Emeric Brun64cc49c2017-10-03 14:46:45 +02001601 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001602 return;
1603
Emeric Brun52a91d32017-08-31 14:41:55 +02001604 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001605 return;
1606
Emeric Brun52a91d32017-08-31 14:41:55 +02001607 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001608 *s->op_st_chg.reason = 0;
1609 s->op_st_chg.status = -1;
1610 if (reason) {
1611 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1612 }
1613 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001614 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001615 s->op_st_chg.code = check->code;
1616 s->op_st_chg.status = check->status;
1617 s->op_st_chg.duration = check->duration;
1618 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001619
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001620 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001621 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001622
Emeric Brun9f0b4582017-10-23 14:39:51 +02001623 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001624 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001625 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001626 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001627 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001628}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001629
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001630/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1631 * enforce either maint mode or drain mode. It is not allowed to set more than
1632 * one flag at once. The equivalent "inherited" flag is propagated to all
1633 * tracking servers. Maintenance mode disables health checks (but not agent
1634 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001635 * is done. If <cause> is non-null, it will be displayed at the end of the log
1636 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001637 *
1638 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001639 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001640void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001641{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001642 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001643
1644 if (!mode)
1645 return;
1646
1647 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001648 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001649 return;
1650
Emeric Brun52a91d32017-08-31 14:41:55 +02001651 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001652 if (cause)
1653 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1654
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001655 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001656 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001657
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001658 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001659 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1660 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001661 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001662
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001663 /* compute the inherited flag to propagate */
1664 if (mode & SRV_ADMF_MAINT)
1665 mode = SRV_ADMF_IMAINT;
1666 else if (mode & SRV_ADMF_DRAIN)
1667 mode = SRV_ADMF_IDRAIN;
1668
Emeric Brun9f0b4582017-10-23 14:39:51 +02001669 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001670 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001671 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001672 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001673 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001674}
1675
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001676/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1677 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1678 * than one flag at once. The equivalent "inherited" flag is propagated to all
1679 * tracking servers. Leaving maintenance mode re-enables health checks. When
1680 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001681 *
1682 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001683 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001684void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001685{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001686 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001687
1688 if (!mode)
1689 return;
1690
1691 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001692 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001693 return;
1694
Emeric Brun52a91d32017-08-31 14:41:55 +02001695 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001696
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001697 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001698 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001699
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001700 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001701 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1702 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001703 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001704
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001705 if (mode & SRV_ADMF_MAINT)
1706 mode = SRV_ADMF_IMAINT;
1707 else if (mode & SRV_ADMF_DRAIN)
1708 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001709
Emeric Brun9f0b4582017-10-23 14:39:51 +02001710 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001711 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001712 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001713 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001714 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001715}
1716
Willy Tarreau757478e2016-11-03 19:22:19 +01001717/* principle: propagate maint and drain to tracking servers. This is useful
1718 * upon startup so that inherited states are correct.
1719 */
1720static void srv_propagate_admin_state(struct server *srv)
1721{
1722 struct server *srv2;
1723
1724 if (!srv->trackers)
1725 return;
1726
1727 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001728 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001729 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001730 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001731
Emeric Brun52a91d32017-08-31 14:41:55 +02001732 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001733 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001734 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001735 }
1736}
1737
1738/* Compute and propagate the admin states for all servers in proxy <px>.
1739 * Only servers *not* tracking another one are considered, because other
1740 * ones will be handled when the server they track is visited.
1741 */
1742void srv_compute_all_admin_states(struct proxy *px)
1743{
1744 struct server *srv;
1745
1746 for (srv = px->srv; srv; srv = srv->next) {
1747 if (srv->track)
1748 continue;
1749 srv_propagate_admin_state(srv);
1750 }
1751}
1752
Willy Tarreaudff55432012-10-10 17:51:05 +02001753/* Note: must not be declared <const> as its list will be overwritten.
1754 * Please take care of keeping this list alphabetically sorted, doing so helps
1755 * all code contributors.
1756 * Optional keywords are also declared with a NULL ->parse() function so that
1757 * the config parser can report an appropriate error when a known keyword was
1758 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001759 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001760 */
1761static struct srv_kw_list srv_kws = { "ALL", { }, {
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001762 { "backup", srv_parse_backup, 0, 1, 1 }, /* Flag as backup server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001763 { "cookie", srv_parse_cookie, 1, 1, 0 }, /* Assign a cookie to the server */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001764 { "disabled", srv_parse_disabled, 0, 1, 1 }, /* Start the server in 'disabled' state */
1765 { "enabled", srv_parse_enabled, 0, 1, 1 }, /* Start the server in 'enabled' state */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001766 { "error-limit", srv_parse_error_limit, 1, 1, 0 }, /* Configure the consecutive count of check failures to consider a server on error */
Amaury Denoyelle69352ec2021-10-18 14:40:29 +02001767 { "ws", srv_parse_ws, 1, 1, 1 }, /* websocket protocol */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001768 { "id", srv_parse_id, 1, 0, 1 }, /* set id# of server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001769 { "init-addr", srv_parse_init_addr, 1, 1, 0 }, /* */
1770 { "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 +01001771 { "maxconn", srv_parse_maxconn, 1, 1, 1 }, /* Set the max number of concurrent connection */
1772 { "maxqueue", srv_parse_maxqueue, 1, 1, 1 }, /* Set the max number of connection to put in queue */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001773 { "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 +01001774 { "minconn", srv_parse_minconn, 1, 1, 1 }, /* Enable a dynamic maxconn limit */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001775 { "namespace", srv_parse_namespace, 1, 1, 0 }, /* Namespace the server socket belongs to (if supported) */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001776 { "no-backup", srv_parse_no_backup, 0, 1, 1 }, /* Flag as non-backup server */
1777 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1, 1 }, /* Disable use of PROXY V1 protocol */
1778 { "no-send-proxy-v2", srv_parse_no_send_proxy_v2, 0, 1, 1 }, /* Disable use of PROXY V2 protocol */
1779 { "no-tfo", srv_parse_no_tfo, 0, 1, 1 }, /* Disable use of TCP Fast Open */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001780 { "non-stick", srv_parse_non_stick, 0, 1, 0 }, /* Disable stick-table persistence */
1781 { "observe", srv_parse_observe, 1, 1, 0 }, /* Enables health adjusting based on observing communication with the server */
1782 { "on-error", srv_parse_on_error, 1, 1, 0 }, /* Configure the action on check failure */
1783 { "on-marked-down", srv_parse_on_marked_down, 1, 1, 0 }, /* Configure the action when a server is marked down */
1784 { "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 +01001785 { "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 */
1786 { "pool-max-conn", srv_parse_pool_max_conn, 1, 1, 1 }, /* Set the max number of orphan idle connections, -1 means unlimited */
1787 { "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 +01001788 { "proto", srv_parse_proto, 1, 1, 1 }, /* Set the proto to use for all outgoing connections */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001789 { "proxy-v2-options", srv_parse_proxy_v2_options, 1, 1, 1 }, /* options for send-proxy-v2 */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001790 { "redir", srv_parse_redir, 1, 1, 0 }, /* Enable redirection mode */
Ilya Shipitsinba13f162021-03-19 22:21:44 +05001791 { "resolve-net", srv_parse_resolve_net, 1, 1, 0 }, /* Set the preferred network range for name resolution */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001792 { "resolve-opts", srv_parse_resolve_opts, 1, 1, 0 }, /* Set options for name resolution */
Ilya Shipitsinba13f162021-03-19 22:21:44 +05001793 { "resolve-prefer", srv_parse_resolve_prefer, 1, 1, 0 }, /* Set the preferred family for name resolution */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001794 { "resolvers", srv_parse_resolvers, 1, 1, 0 }, /* Configure the resolver to use for name resolution */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001795 { "send-proxy", srv_parse_send_proxy, 0, 1, 1 }, /* Enforce use of PROXY V1 protocol */
1796 { "send-proxy-v2", srv_parse_send_proxy_v2, 0, 1, 1 }, /* Enforce use of PROXY V2 protocol */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001797 { "slowstart", srv_parse_slowstart, 1, 1, 0 }, /* Set the warm-up timer for a previously failed server */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001798 { "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 +01001799 { "stick", srv_parse_stick, 0, 1, 0 }, /* Enable stick-table persistence */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001800 { "tfo", srv_parse_tfo, 0, 1, 1 }, /* enable TCP Fast Open of server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001801 { "track", srv_parse_track, 1, 1, 0 }, /* Set the current state of the server, tracking another one */
1802 { "socks4", srv_parse_socks4, 1, 1, 0 }, /* Set the socks4 proxy of the server*/
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001803 { "usesrc", srv_parse_usesrc, 0, 1, 1 }, /* safe-guard against usesrc without preceding <source> keyword */
1804 { "weight", srv_parse_weight, 1, 1, 1 }, /* Set the load-balancing weight */
Willy Tarreaudff55432012-10-10 17:51:05 +02001805 { NULL, NULL, 0 },
1806}};
1807
Willy Tarreau0108d902018-11-25 19:14:37 +01001808INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001809
Willy Tarreau004e0452013-11-21 11:22:01 +01001810/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001811 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001812 * state is automatically disabled if the time is elapsed. If <must_update> is
1813 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001814 *
1815 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001816 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001817void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001818{
1819 struct proxy *px = sv->proxy;
1820 unsigned w;
1821
1822 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1823 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001824 if (sv->next_state == SRV_ST_STARTING)
1825 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001826 }
1827
1828 /* We must take care of not pushing the server to full throttle during slow starts.
1829 * It must also start immediately, at least at the minimal step when leaving maintenance.
1830 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001831 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001832 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1833 else
1834 w = px->lbprm.wdiv;
1835
Emeric Brun52a91d32017-08-31 14:41:55 +02001836 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001837
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001838 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001839 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001840 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001841}
1842
Willy Tarreaubaaee002006-06-26 02:48:02 +02001843/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001844 * Parses weight_str and configures sv accordingly.
1845 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001846 *
1847 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001848 */
1849const char *server_parse_weight_change_request(struct server *sv,
1850 const char *weight_str)
1851{
1852 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001853 long int w;
1854 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001855
1856 px = sv->proxy;
1857
1858 /* if the weight is terminated with '%', it is set relative to
1859 * the initial weight, otherwise it is absolute.
1860 */
1861 if (!*weight_str)
1862 return "Require <weight> or <weight%>.\n";
1863
Simon Hormanb796afa2013-02-12 10:45:53 +09001864 w = strtol(weight_str, &end, 10);
1865 if (end == weight_str)
1866 return "Empty weight string empty or preceded by garbage";
1867 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001868 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001869 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001870 /* Avoid integer overflow */
1871 if (w > 25600)
1872 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001873 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001874 if (w > 256)
1875 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001876 }
1877 else if (w < 0 || w > 256)
1878 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001879 else if (end[0] != '\0')
1880 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001881
1882 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1883 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1884
1885 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001886 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001887
1888 return NULL;
1889}
1890
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001891/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001892 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1893 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001894 * Returns:
1895 * - error string on error
1896 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001897 *
1898 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001899 */
1900const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001901 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001902{
1903 unsigned char ip[INET6_ADDRSTRLEN];
1904
1905 if (inet_pton(AF_INET6, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001906 srv_update_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001907 return NULL;
1908 }
1909 if (inet_pton(AF_INET, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001910 srv_update_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001911 return NULL;
1912 }
1913
1914 return "Could not understand IP address format.\n";
1915}
1916
Willy Tarreau46b7f532018-08-21 11:54:26 +02001917/*
1918 * Must be called with the server lock held.
1919 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001920const char *server_parse_maxconn_change_request(struct server *sv,
1921 const char *maxconn_str)
1922{
1923 long int v;
1924 char *end;
1925
1926 if (!*maxconn_str)
1927 return "Require <maxconn>.\n";
1928
1929 v = strtol(maxconn_str, &end, 10);
1930 if (end == maxconn_str)
1931 return "maxconn string empty or preceded by garbage";
1932 else if (end[0] != '\0')
1933 return "Trailing garbage in maxconn string";
1934
1935 if (sv->maxconn == sv->minconn) { // static maxconn
1936 sv->maxconn = sv->minconn = v;
1937 } else { // dynamic maxconn
1938 sv->maxconn = v;
1939 }
1940
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02001941 /* server_parse_maxconn_change_request requires the server lock held.
1942 * Specify it to process_srv_queue to prevent a deadlock.
1943 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001944 if (may_dequeue_tasks(sv, sv->proxy))
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02001945 process_srv_queue(sv, 1);
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001946
1947 return NULL;
1948}
1949
William Lallemand71048532021-10-20 13:28:41 +02001950#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001951static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1952 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001953{
1954 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001955 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001956 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001957 NULL,
1958 };
1959
1960 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001961 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001962
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001963 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001964}
1965
1966static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1967{
1968 struct sample_expr *expr;
1969
1970 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 +01001971 if (!expr) {
1972 memprintf(err, "error detected while parsing sni expression : %s", *err);
1973 return ERR_ALERT | ERR_FATAL;
1974 }
1975
1976 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1977 memprintf(err, "error detected while parsing sni expression : "
1978 " fetch method '%s' extracts information from '%s', "
1979 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001980 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001981 return ERR_ALERT | ERR_FATAL;
1982 }
1983
1984 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1985 release_sample_expr(newsrv->ssl_ctx.sni);
1986 newsrv->ssl_ctx.sni = expr;
1987
1988 return 0;
1989}
William Lallemand71048532021-10-20 13:28:41 +02001990#endif
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001991
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001992static 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 +01001993{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001994 char *msg = "error encountered while processing ";
1995 char *quote = "'";
1996 char *token = args[cur_arg];
1997
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001998 if (err && *err) {
1999 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002000 msg = *err;
2001 quote = "";
2002 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01002003 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002004
2005 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
2006 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
2007 file, linenum, args[0], args[1],
2008 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01002009 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002010 ha_alert("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
2011 file, linenum, args[0], args[1],
2012 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01002013}
2014
Christopher Faulet5e5675d2022-08-03 11:21:14 +02002015static void srv_conn_src_sport_range_cpy(struct server *srv, const struct server *src)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002016{
2017 int range_sz;
2018
2019 range_sz = src->conn_src.sport_range->size;
2020 if (range_sz > 0) {
2021 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
2022 if (srv->conn_src.sport_range != NULL) {
2023 int i;
2024
2025 for (i = 0; i < range_sz; i++) {
2026 srv->conn_src.sport_range->ports[i] =
2027 src->conn_src.sport_range->ports[i];
2028 }
2029 }
2030 }
2031}
2032
2033/*
2034 * Copy <src> server connection source settings to <srv> server everything needed.
2035 */
Christopher Faulet5e5675d2022-08-03 11:21:14 +02002036static void srv_conn_src_cpy(struct server *srv, const struct server *src)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002037{
2038 srv->conn_src.opts = src->conn_src.opts;
2039 srv->conn_src.source_addr = src->conn_src.source_addr;
2040
2041 /* Source port range copy. */
2042 if (src->conn_src.sport_range != NULL)
2043 srv_conn_src_sport_range_cpy(srv, src);
2044
2045#ifdef CONFIG_HAP_TRANSPARENT
2046 if (src->conn_src.bind_hdr_name != NULL) {
2047 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
2048 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
2049 }
2050 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
2051 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
2052#endif
2053 if (src->conn_src.iface_name != NULL)
2054 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
2055}
2056
2057/*
2058 * Copy <src> server SSL settings to <srv> server allocating
2059 * everything needed.
2060 */
2061#if defined(USE_OPENSSL)
Christopher Faulet5e5675d2022-08-03 11:21:14 +02002062static void srv_ssl_settings_cpy(struct server *srv, const struct server *src)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002063{
Christopher Faulet7cbd1562021-12-01 09:50:41 +01002064 /* <src> is the current proxy's default server and SSL is enabled */
William Lallemand6338b7d2021-12-28 18:47:17 +01002065 BUG_ON(src->ssl_ctx.ctx != NULL); /* the SSL_CTX must never be initialized in a default-server */
2066
Christopher Faulet7cbd1562021-12-01 09:50:41 +01002067 if (src == &srv->proxy->defsrv && src->use_ssl == 1)
2068 srv->flags |= SRV_F_DEFSRV_USE_SSL;
2069
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002070 if (src->ssl_ctx.ca_file != NULL)
2071 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
2072 if (src->ssl_ctx.crl_file != NULL)
2073 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
William Lallemand6338b7d2021-12-28 18:47:17 +01002074 if (src->ssl_ctx.client_crt != NULL)
2075 srv->ssl_ctx.client_crt = strdup(src->ssl_ctx.client_crt);
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002076
2077 srv->ssl_ctx.verify = src->ssl_ctx.verify;
2078
Remi Tricot-Le Breton3b0f3e02021-07-13 18:28:22 +02002079
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002080 if (src->ssl_ctx.verify_host != NULL)
2081 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
2082 if (src->ssl_ctx.ciphers != NULL)
2083 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02002084 if (src->ssl_ctx.options)
2085 srv->ssl_ctx.options = src->ssl_ctx.options;
2086 if (src->ssl_ctx.methods.flags)
2087 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
2088 if (src->ssl_ctx.methods.min)
2089 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
2090 if (src->ssl_ctx.methods.max)
2091 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
2092
William Lallemand71048532021-10-20 13:28:41 +02002093#ifdef HAVE_SSL_CTX_SET_CIPHERSUITES
Dirkjan Bussink415150f2018-09-14 11:14:21 +02002094 if (src->ssl_ctx.ciphersuites != NULL)
2095 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
William Lallemand71048532021-10-20 13:28:41 +02002096#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002097 if (src->sni_expr != NULL)
2098 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01002099
William Lallemand71048532021-10-20 13:28:41 +02002100#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Olivier Houchardc7566002018-11-20 23:33:50 +01002101 if (src->ssl_ctx.alpn_str) {
2102 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
2103 if (srv->ssl_ctx.alpn_str) {
2104 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
2105 src->ssl_ctx.alpn_len);
2106 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
2107 }
2108 }
William Lallemand71048532021-10-20 13:28:41 +02002109#endif
2110#ifdef OPENSSL_NPN_NEGOTIATED
Olivier Houchardc7566002018-11-20 23:33:50 +01002111 if (src->ssl_ctx.npn_str) {
2112 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
2113 if (srv->ssl_ctx.npn_str) {
2114 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
2115 src->ssl_ctx.npn_len);
2116 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
2117 }
2118 }
William Lallemand71048532021-10-20 13:28:41 +02002119#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002120}
2121#endif
2122
2123/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002124 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002125 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002126 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002127 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002128int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002129{
Christopher Faulet67957bd2017-09-27 11:00:59 +02002130 char *hostname_dn;
2131 int hostname_len, hostname_dn_len;
2132
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002133 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002134 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002135
Christopher Faulet67957bd2017-09-27 11:00:59 +02002136 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002137 hostname_dn = trash.area;
Willy Tarreauc1c765f2021-10-14 07:49:49 +02002138 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len,
Emeric Brund30e9a12020-12-23 18:49:16 +01002139 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02002140 if (hostname_dn_len == -1)
2141 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02002142
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002143
Christopher Faulet67957bd2017-09-27 11:00:59 +02002144 free(srv->hostname);
2145 free(srv->hostname_dn);
2146 srv->hostname = strdup(hostname);
2147 srv->hostname_dn = strdup(hostname_dn);
2148 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002149 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002150 goto err;
2151
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002152 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002153
2154 err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002155 ha_free(&srv->hostname);
2156 ha_free(&srv->hostname_dn);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002157 return -1;
2158}
2159
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002160/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002161 * Copy <src> server settings to <srv> server allocating
2162 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002163 * This function is not supposed to be called at any time, but only
2164 * during server settings parsing or during server allocations from
2165 * a server template, and just after having calloc()'ed a new server.
2166 * So, <src> may only be a default server (when parsing server settings)
2167 * or a server template (during server allocations from a server template).
2168 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
2169 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002170 */
Christopher Faulet29962f72022-08-03 11:28:08 +02002171void srv_settings_cpy(struct server *srv, const struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002172{
2173 /* Connection source settings copy */
2174 srv_conn_src_cpy(srv, src);
2175
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002176 if (srv_tmpl) {
2177 srv->addr = src->addr;
2178 srv->svc_port = src->svc_port;
2179 }
2180
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002181 srv->pp_opts = src->pp_opts;
2182 if (src->rdr_pfx != NULL) {
2183 srv->rdr_pfx = strdup(src->rdr_pfx);
2184 srv->rdr_len = src->rdr_len;
2185 }
2186 if (src->cookie != NULL) {
2187 srv->cookie = strdup(src->cookie);
2188 srv->cklen = src->cklen;
2189 }
2190 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01002191 srv->check.addr = src->check.addr;
2192 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002193 srv->check.use_ssl = src->check.use_ssl;
2194 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01002195 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01002196 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05002197 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002198 /* Note: 'flags' field has potentially been already initialized. */
2199 srv->flags |= src->flags;
2200 srv->do_check = src->do_check;
2201 srv->do_agent = src->do_agent;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002202 srv->check.inter = src->check.inter;
2203 srv->check.fastinter = src->check.fastinter;
2204 srv->check.downinter = src->check.downinter;
2205 srv->agent.use_ssl = src->agent.use_ssl;
2206 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002207
2208 if (src->agent.tcpcheck_rules) {
2209 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
2210 if (srv->agent.tcpcheck_rules) {
2211 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
2212 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
2213 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
2214 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
2215 &src->agent.tcpcheck_rules->preset_vars);
2216 }
2217 }
2218
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002219 srv->agent.inter = src->agent.inter;
2220 srv->agent.fastinter = src->agent.fastinter;
2221 srv->agent.downinter = src->agent.downinter;
2222 srv->maxqueue = src->maxqueue;
Amaury Denoyelle8e99b842021-10-18 14:39:57 +02002223 srv->ws = src->ws;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002224 srv->minconn = src->minconn;
2225 srv->maxconn = src->maxconn;
2226 srv->slowstart = src->slowstart;
2227 srv->observe = src->observe;
2228 srv->onerror = src->onerror;
2229 srv->onmarkeddown = src->onmarkeddown;
2230 srv->onmarkedup = src->onmarkedup;
2231 if (src->trackit != NULL)
2232 srv->trackit = strdup(src->trackit);
2233 srv->consecutive_errors_limit = src->consecutive_errors_limit;
2234 srv->uweight = srv->iweight = src->iweight;
2235
2236 srv->check.send_proxy = src->check.send_proxy;
2237 /* health: up, but will fall down at first failure */
2238 srv->check.rise = srv->check.health = src->check.rise;
2239 srv->check.fall = src->check.fall;
2240
2241 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02002242 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
2243 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
2244 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002245 srv->check.state |= CHK_ST_PAUSED;
2246 srv->check.health = 0;
2247 }
2248
2249 /* health: up but will fall down at first failure */
2250 srv->agent.rise = srv->agent.health = src->agent.rise;
2251 srv->agent.fall = src->agent.fall;
2252
2253 if (src->resolvers_id != NULL)
2254 srv->resolvers_id = strdup(src->resolvers_id);
Emeric Brun21fbeed2020-12-23 18:01:04 +01002255 srv->resolv_opts.family_prio = src->resolv_opts.family_prio;
2256 srv->resolv_opts.accept_duplicate_ip = src->resolv_opts.accept_duplicate_ip;
2257 srv->resolv_opts.ignore_weight = src->resolv_opts.ignore_weight;
2258 if (srv->resolv_opts.family_prio == AF_UNSPEC)
2259 srv->resolv_opts.family_prio = AF_INET6;
2260 memcpy(srv->resolv_opts.pref_net,
2261 src->resolv_opts.pref_net,
2262 sizeof srv->resolv_opts.pref_net);
2263 srv->resolv_opts.pref_net_nb = src->resolv_opts.pref_net_nb;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002264
2265 srv->init_addr_methods = src->init_addr_methods;
2266 srv->init_addr = src->init_addr;
2267#if defined(USE_OPENSSL)
2268 srv_ssl_settings_cpy(srv, src);
2269#endif
2270#ifdef TCP_USER_TIMEOUT
2271 srv->tcp_ut = src->tcp_ut;
2272#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02002273 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01002274 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02002275 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01002276 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01002277 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02002278
Olivier Houchard8da5f982017-08-04 18:35:36 +02002279 if (srv_tmpl)
2280 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08002281
2282 srv->check.via_socks4 = src->check.via_socks4;
2283 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002284}
2285
Willy Tarreau198e92a2021-03-05 10:23:32 +01002286/* allocate a server and attach it to the global servers_list. Returns
2287 * the server on success, otherwise NULL.
2288 */
William Lallemand313bfd12018-10-26 14:47:32 +02002289struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002290{
2291 struct server *srv;
2292
2293 srv = calloc(1, sizeof *srv);
2294 if (!srv)
2295 return NULL;
2296
2297 srv->obj_type = OBJ_TYPE_SERVER;
2298 srv->proxy = proxy;
Patrick Hemmer0355dab2018-05-11 12:52:31 -04002299 srv->pendconns = EB_ROOT;
Willy Tarreau2b718102021-04-21 07:32:39 +02002300 LIST_APPEND(&servers_list, &srv->global_list);
Emeric Brun0c4a8a32021-06-11 10:48:45 +02002301 LIST_INIT(&srv->srv_rec_item);
Emeric Brunf9ca5d82021-06-11 10:08:05 +02002302 LIST_INIT(&srv->ip_rec_item);
Christopher Faulet40a007c2017-07-03 15:41:01 +02002303
Emeric Brun52a91d32017-08-31 14:41:55 +02002304 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002305 srv->last_change = now.tv_sec;
2306
Christopher Faulet38290462020-04-21 11:46:40 +02002307 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002308 srv->check.status = HCHK_STATUS_INI;
2309 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01002310 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02002311 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002312
Christopher Faulet38290462020-04-21 11:46:40 +02002313 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002314 srv->agent.status = HCHK_STATUS_INI;
2315 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01002316 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002317 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
Frédéric Lécaillef46c10c2020-11-23 14:29:28 +01002318#if defined(USE_QUIC)
2319 srv->cids = EB_ROOT_UNIQUE;
2320#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002321
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01002322 srv->extra_counters = NULL;
William Lallemand3ce6eed2021-02-08 10:43:44 +01002323#ifdef USE_OPENSSL
2324 HA_RWLOCK_INIT(&srv->ssl_ctx.lock);
2325#endif
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01002326
Willy Tarreau975b1552019-06-06 16:25:55 +02002327 /* please don't put default server settings here, they are set in
Willy Tarreau144289b2021-02-12 08:19:01 +01002328 * proxy_preset_defaults().
Willy Tarreau975b1552019-06-06 16:25:55 +02002329 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002330 return srv;
2331}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002332
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02002333/* Increment the dynamic server refcount. */
Amaury Denoyelle4a699422021-08-25 14:39:53 +02002334void srv_use_dynsrv(struct server *srv)
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02002335{
2336 BUG_ON(!(srv->flags & SRV_F_DYNAMIC));
2337 HA_ATOMIC_INC(&srv->refcount_dynsrv);
2338}
2339
2340/* Decrement the dynamic server refcount. */
2341static uint srv_release_dynsrv(struct server *srv)
2342{
2343 BUG_ON(!(srv->flags & SRV_F_DYNAMIC));
2344 return HA_ATOMIC_SUB_FETCH(&srv->refcount_dynsrv, 1);
2345}
2346
Amaury Denoyelleff836742021-08-09 15:08:54 +02002347/* Deallocate a server <srv> and its member. <srv> must be allocated. For
2348 * dynamic servers, its refcount is decremented first. The free operations are
2349 * conducted only if the refcount is nul, unless the process is stopping.
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002350 *
2351 * As a convenience, <srv.next> is returned if srv is not NULL. It may be useful
2352 * when calling free_server on the list of servers.
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002353 */
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002354struct server *free_server(struct server *srv)
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002355{
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002356 struct server *next = NULL;
2357
2358 next = srv->next;
2359
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02002360 /* For dynamic servers, decrement the reference counter. Only free the
2361 * server when reaching zero.
2362 */
Amaury Denoyelleff836742021-08-09 15:08:54 +02002363 if (likely(!(global.mode & MODE_STOPPING))) {
2364 if (srv->flags & SRV_F_DYNAMIC) {
2365 if (srv_release_dynsrv(srv))
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002366 goto end;
Amaury Denoyelleff836742021-08-09 15:08:54 +02002367 }
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02002368 }
2369
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002370 task_destroy(srv->warmup);
Christopher Faulet2c0f5272021-06-15 16:17:17 +02002371 task_destroy(srv->srvrq_check);
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002372
2373 free(srv->id);
2374 free(srv->cookie);
2375 free(srv->hostname);
2376 free(srv->hostname_dn);
2377 free((char*)srv->conf.file);
2378 free(srv->per_thr);
2379 free(srv->curr_idle_thr);
2380 free(srv->resolvers_id);
2381 free(srv->addr_node.key);
Amaury Denoyellefb247942021-04-20 16:48:22 +02002382 free(srv->lb_nodes);
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002383
2384 if (srv->use_ssl == 1 || srv->check.use_ssl == 1 || (srv->proxy->options & PR_O_TCPCHK_SSL)) {
2385 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->destroy_srv)
2386 xprt_get(XPRT_SSL)->destroy_srv(srv);
2387 }
2388 HA_SPIN_DESTROY(&srv->lock);
2389
Willy Tarreau2b718102021-04-21 07:32:39 +02002390 LIST_DELETE(&srv->global_list);
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002391
2392 EXTRA_COUNTERS_FREE(srv->extra_counters);
2393
2394 free(srv);
2395 srv = NULL;
Amaury Denoyellebbe608a2021-08-25 15:03:46 +02002396
2397 end:
2398 return next;
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002399}
2400
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002401/*
2402 * Parse as much as possible such a range string argument: low[-high]
2403 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
2404 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
2405 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
2406 * Returns 0 if succeeded, -1 if not.
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002407 */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002408static int _srv_parse_tmpl_range(struct server *srv, const char *arg,
2409 int *nb_low, int *nb_high)
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002410{
2411 char *nb_high_arg;
2412
2413 *nb_high = 0;
2414 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002415 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002416
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002417 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002418 *nb_high_arg++ = '\0';
2419 *nb_high = atoi(nb_high_arg);
2420 }
2421 else {
2422 *nb_high += *nb_low;
2423 *nb_low = 1;
2424 }
2425
2426 if (*nb_low < 0 || *nb_high < *nb_low)
2427 return -1;
2428
2429 return 0;
2430}
2431
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002432/* Parse as much as possible such a range string argument: low[-high]
2433 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
2434 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
2435 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002436 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002437 * initialize a new server on startup.
2438 *
2439 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
2440 * Returns 0 if succeeded, -1 if not.
2441 */
2442static inline void _srv_parse_set_id_from_prefix(struct server *srv,
2443 const char *prefix, int nb)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002444{
2445 chunk_printf(&trash, "%s%d", prefix, nb);
2446 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002447 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002448}
2449
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002450/* Initialize as much as possible servers from <srv> server template.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002451 * Note that a server template is a special server with
2452 * a few different parameters than a server which has
2453 * been parsed mostly the same way as a server.
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002454 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002455 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002456 * initialize a new server on startup.
2457 *
Joseph Herlant44466822018-11-15 08:57:51 -08002458 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002459 * 'srv' template included.
2460 */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002461static int _srv_parse_tmpl_init(struct server *srv, struct proxy *px)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002462{
2463 int i;
2464 struct server *newsrv;
2465
2466 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 +02002467 newsrv = new_server(px);
2468 if (!newsrv)
2469 goto err;
2470
Christopher Faulet75bef002020-11-02 22:04:55 +01002471 newsrv->conf.file = strdup(srv->conf.file);
2472 newsrv->conf.line = srv->conf.line;
2473
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002474 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002475 srv_prepare_for_resolution(newsrv, srv->hostname);
William Lallemand71048532021-10-20 13:28:41 +02002476#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002477 if (newsrv->sni_expr) {
2478 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
2479 if (!newsrv->ssl_ctx.sni)
2480 goto err;
2481 }
William Lallemand71048532021-10-20 13:28:41 +02002482#endif
Emeric Brun0c4a8a32021-06-11 10:48:45 +02002483 /* append to list of servers available to receive an hostname */
Emeric Brun3ecaf532021-06-14 10:02:18 +02002484 if (newsrv->srvrq)
2485 LIST_APPEND(&newsrv->srvrq->attached_servers, &newsrv->srv_rec_item);
Emeric Brun0c4a8a32021-06-11 10:48:45 +02002486
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002487 /* Set this new server ID. */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002488 _srv_parse_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002489
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002490 /* Linked backwards first. This will be restablished after parsing. */
2491 newsrv->next = px->srv;
2492 px->srv = newsrv;
2493 }
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002494 _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 +02002495
2496 return i - srv->tmpl_info.nb_low;
2497
2498 err:
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002499 _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 +02002500 if (newsrv) {
William Lallemand71048532021-10-20 13:28:41 +02002501#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002502 release_sample_expr(newsrv->ssl_ctx.sni);
William Lallemand71048532021-10-20 13:28:41 +02002503#endif
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002504 free_check(&newsrv->agent);
2505 free_check(&newsrv->check);
Willy Tarreau2b718102021-04-21 07:32:39 +02002506 LIST_DELETE(&newsrv->global_list);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002507 }
2508 free(newsrv);
2509 return i - srv->tmpl_info.nb_low;
2510}
2511
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002512/* Allocate a new server pointed by <srv> and try to parse the first arguments
2513 * in <args> as an address for a server or an address-range for a template or
2514 * nothing for a default-server. <cur_arg> is incremented to the next argument.
2515 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002516 * This function is first intended to be used through parse_server to
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002517 * initialize a new server on startup.
2518 *
2519 * A mask of errors is returned. On a parsing error, ERR_FATAL is set. In case
2520 * of memory exhaustion, ERR_ABORT is set. If the server cannot be allocated,
2521 * <srv> will be set to NULL.
2522 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002523static int _srv_parse_init(struct server **srv, char **args, int *cur_arg,
2524 struct proxy *curproxy,
2525 int parse_flags, char **errmsg)
Willy Tarreau272adea2014-03-31 10:39:59 +02002526{
2527 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002528 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02002529 int err_code = 0;
Willy Tarreau07101d52015-09-08 16:16:35 +02002530 char *fqdn = NULL;
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002531 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002532
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002533 *srv = NULL;
2534
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002535 /* There is no mandatory first arguments for default server. */
2536 if (parse_flags & SRV_PARSE_PARSE_ADDR) {
2537 if (parse_flags & SRV_PARSE_TEMPLATE) {
2538 if (!*args[3]) {
2539 /* 'server-template' line number of argument check. */
2540 memprintf(errmsg, "'%s' expects <prefix> <nb | range> <addr>[:<port>] as arguments.",
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002541 args[0]);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002542 err_code |= ERR_ALERT | ERR_FATAL;
2543 goto out;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002544 }
2545
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002546 err = invalid_prefix_char(args[1]);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002547 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002548 else {
2549 if (!*args[2]) {
2550 /* 'server' line number of argument check. */
2551 memprintf(errmsg, "'%s' expects <name> and <addr>[:<port>] as arguments.",
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002552 args[0]);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002553 err_code |= ERR_ALERT | ERR_FATAL;
2554 goto out;
2555 }
2556
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002557 err = invalid_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002558 }
2559
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002560 if (err) {
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002561 memprintf(errmsg, "character '%c' is not permitted in %s %s '%s'.",
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002562 *err, args[0], !(parse_flags & SRV_PARSE_TEMPLATE) ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002563 err_code |= ERR_ALERT | ERR_FATAL;
2564 goto out;
2565 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002566 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002567
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002568 *cur_arg = 2;
2569 if (parse_flags & SRV_PARSE_TEMPLATE) {
2570 /* Parse server-template <nb | range> arg. */
2571 if (_srv_parse_tmpl_range(newsrv, args[*cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
2572 memprintf(errmsg, "Wrong %s number or range arg '%s'.",
2573 args[0], args[*cur_arg]);
2574 err_code |= ERR_ALERT | ERR_FATAL;
2575 goto out;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002576 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002577 (*cur_arg)++;
2578 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002579
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002580 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
2581 struct sockaddr_storage *sk;
2582 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002583
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002584 *srv = newsrv = new_server(curproxy);
2585 if (!newsrv) {
2586 memprintf(errmsg, "out of memory.");
2587 err_code |= ERR_ALERT | ERR_ABORT;
2588 goto out;
2589 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002590
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002591 if (parse_flags & SRV_PARSE_TEMPLATE) {
2592 newsrv->tmpl_info.nb_low = tmpl_range_low;
2593 newsrv->tmpl_info.nb_high = tmpl_range_high;
2594 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002595
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002596 if (parse_flags & SRV_PARSE_DYNAMIC)
2597 newsrv->flags |= SRV_F_DYNAMIC;
2598
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002599 /* Note: for a server template, its id is its prefix.
2600 * This is a temporary id which will be used for server allocations to come
2601 * after parsing.
2602 */
2603 if (!(parse_flags & SRV_PARSE_TEMPLATE))
2604 newsrv->id = strdup(args[1]);
2605 else
2606 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002607
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002608 /* several ways to check the port component :
2609 * - IP => port=+0, relative (IPv4 only)
2610 * - IP: => port=+0, relative
2611 * - IP:N => port=N, absolute
2612 * - IP:+N => port=+N, relative
2613 * - IP:-N => port=-N, relative
2614 */
2615 if (!(parse_flags & SRV_PARSE_PARSE_ADDR))
2616 goto skip_addr;
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002617
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002618 sk = str2sa_range(args[*cur_arg], &port, &port1, &port2, NULL, NULL,
2619 errmsg, NULL, &fqdn,
2620 (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);
2621 if (!sk) {
2622 memprintf(errmsg, "'%s %s' : %s", args[0], args[1], *errmsg);
2623 err_code |= ERR_ALERT | ERR_FATAL;
2624 goto out;
2625 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002626
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002627 if (!port1 || !port2) {
2628 /* no port specified, +offset, -offset */
2629 newsrv->flags |= SRV_F_MAPPORTS;
2630 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002631
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002632 /* save hostname and create associated name resolution */
2633 if (fqdn) {
2634 if (fqdn[0] == '_') { /* SRV record */
2635 /* Check if a SRV request already exists, and if not, create it */
2636 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
2637 newsrv->srvrq = new_resolv_srvrq(newsrv, fqdn);
2638 if (newsrv->srvrq == NULL) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002639 err_code |= ERR_ALERT | ERR_FATAL;
2640 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002641 }
Christopher Faulet08736f92021-06-29 20:52:35 +02002642 LIST_APPEND(&newsrv->srvrq->attached_servers, &newsrv->srv_rec_item);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002643 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002644 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
2645 memprintf(errmsg, "Can't create DNS resolution for server '%s'",
2646 newsrv->id);
Willy Tarreau272adea2014-03-31 10:39:59 +02002647 err_code |= ERR_ALERT | ERR_FATAL;
2648 goto out;
2649 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002650 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002651
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002652 newsrv->addr = *sk;
2653 newsrv->svc_port = port;
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02002654 /*
2655 * we don't need to lock the server here, because
2656 * we are in the process of initializing.
2657 *
2658 * Note that the server is not attached into the proxy tree if
2659 * this is a dynamic server.
2660 */
2661 srv_set_addr_desc(newsrv, !(parse_flags & SRV_PARSE_DYNAMIC));
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002662
2663 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
2664 memprintf(errmsg, "Unknown protocol family %d '%s'",
2665 newsrv->addr.ss_family, args[*cur_arg]);
2666 err_code |= ERR_ALERT | ERR_FATAL;
2667 goto out;
Willy Tarreau272adea2014-03-31 10:39:59 +02002668 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002669
2670 (*cur_arg)++;
2671 skip_addr:
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002672 if (!(parse_flags & SRV_PARSE_DYNAMIC)) {
2673 /* Copy default server settings to new server */
2674 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
2675 } else {
2676 /* Initialize dynamic server weight to 1 */
2677 newsrv->uweight = newsrv->iweight = 1;
2678
2679 /* A dynamic server is disabled on startup */
2680 newsrv->next_admin = SRV_ADMF_FMAINT;
2681 newsrv->next_state = SRV_ST_STOPPED;
2682 server_recalc_eweight(newsrv, 0);
2683 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002684 HA_SPIN_INIT(&newsrv->lock);
2685 }
2686 else {
2687 *srv = newsrv = &curproxy->defsrv;
2688 *cur_arg = 1;
2689 newsrv->resolv_opts.family_prio = AF_INET6;
2690 newsrv->resolv_opts.accept_duplicate_ip = 0;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002691 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002692
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002693 free(fqdn);
2694 return 0;
Willy Tarreau9faebe32019-06-07 19:00:37 +02002695
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002696out:
2697 free(fqdn);
2698 return err_code;
2699}
Willy Tarreau272adea2014-03-31 10:39:59 +02002700
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002701/* Parse the server keyword in <args>.
2702 * <cur_arg> is incremented beyond the keyword optional value. Note that this
2703 * might not be the case if an error is reported.
2704 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002705 * This function is first intended to be used through parse_server to
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002706 * initialize a new server on startup.
2707 *
2708 * A mask of errors is returned. ERR_FATAL is set if the parsing should be
2709 * interrupted.
2710 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002711static int _srv_parse_kw(struct server *srv, char **args, int *cur_arg,
2712 struct proxy *curproxy,
2713 int parse_flags, char **errmsg)
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002714{
2715 int err_code = 0;
2716 struct srv_kw *kw;
2717 const char *best;
Willy Tarreau272adea2014-03-31 10:39:59 +02002718
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002719 kw = srv_find_kw(args[*cur_arg]);
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002720 if (!kw) {
2721 best = srv_find_best_kw(args[*cur_arg]);
2722 if (best)
2723 memprintf(errmsg, "unknown keyword '%s'; did you mean '%s' maybe ?",
2724 args[*cur_arg], best);
2725 else
2726 memprintf(errmsg, "unknown keyword '%s'.",
2727 args[*cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002728
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002729 return ERR_ALERT | ERR_FATAL;
2730 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002731
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002732 if (!kw->parse) {
2733 memprintf(errmsg, "'%s' option is not implemented in this version (check build options)",
2734 args[*cur_arg]);
2735 err_code = ERR_ALERT | ERR_FATAL;
2736 goto out;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002737 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002738
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002739 if ((parse_flags & SRV_PARSE_DEFAULT_SERVER) && !kw->default_ok) {
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002740 memprintf(errmsg, "'%s' option is not accepted in default-server sections",
2741 args[*cur_arg]);
2742 err_code = ERR_ALERT;
2743 goto out;
2744 }
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002745 else if ((parse_flags & SRV_PARSE_DYNAMIC) && !kw->dynamic_ok) {
2746 memprintf(errmsg, "'%s' option is not accepted for dynamic server",
2747 args[*cur_arg]);
2748 err_code |= ERR_ALERT;
2749 goto out;
2750 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002751
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002752 err_code = kw->parse(args, cur_arg, curproxy, srv, errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002753
2754out:
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002755 if (kw->skip != -1)
2756 *cur_arg += 1 + kw->skip;
2757
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002758 return err_code;
2759}
2760
William Lallemand71048532021-10-20 13:28:41 +02002761#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002762/* This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002763 * initialize a new server on startup.
2764 */
2765static int _srv_parse_sni_expr_init(char **args, int cur_arg,
2766 struct server *srv, struct proxy *proxy,
2767 char **errmsg)
2768{
2769 int ret;
2770
2771 if (!srv->sni_expr)
2772 return 0;
2773
2774 ret = server_parse_sni_expr(srv, proxy, errmsg);
2775 if (!ret)
2776 return 0;
2777
2778 return ret;
2779}
William Lallemand71048532021-10-20 13:28:41 +02002780#endif
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002781
2782/* Server initializations finalization.
2783 * Initialize health check, agent check and SNI expression if enabled.
2784 * Must not be called for a default server instance.
2785 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002786 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002787 * initialize a new server on startup.
2788 */
2789static int _srv_parse_finalize(char **args, int cur_arg,
2790 struct server *srv, struct proxy *px,
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002791 int parse_flags, char **errmsg)
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002792{
William Lallemand71048532021-10-20 13:28:41 +02002793#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002794 int ret;
William Lallemand71048532021-10-20 13:28:41 +02002795#endif
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002796
2797 if (srv->do_check && srv->trackit) {
2798 memprintf(errmsg, "unable to enable checks and tracking at the same time!");
2799 return ERR_ALERT | ERR_FATAL;
2800 }
2801
2802 if (srv->do_agent && !srv->agent.port) {
2803 memprintf(errmsg, "server %s does not have agent port. Agent check has been disabled.",
2804 srv->id);
2805 return ERR_ALERT | ERR_FATAL;
2806 }
2807
William Lallemand71048532021-10-20 13:28:41 +02002808#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002809 if ((ret = _srv_parse_sni_expr_init(args, cur_arg, srv, px, errmsg)) != 0)
2810 return ret;
William Lallemand71048532021-10-20 13:28:41 +02002811#endif
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002812
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002813 /* A dynamic server is disabled on startup. It must not be counted as
2814 * an active backend entry.
2815 */
2816 if (!(parse_flags & SRV_PARSE_DYNAMIC)) {
2817 if (srv->flags & SRV_F_BACKUP)
2818 px->srv_bck++;
2819 else
2820 px->srv_act++;
2821 }
2822
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002823 srv_lb_commit_status(srv);
2824
2825 return 0;
2826}
2827
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002828int parse_server(const char *file, int linenum, char **args,
2829 struct proxy *curproxy, const struct proxy *defproxy,
2830 int parse_flags)
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002831{
2832 struct server *newsrv = NULL;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002833 char *errmsg = NULL;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002834 int err_code = 0;
2835
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002836 int cur_arg;
Willy Tarreau272adea2014-03-31 10:39:59 +02002837
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002838 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER) && curproxy == defproxy) {
2839 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
2840 err_code |= ERR_ALERT | ERR_FATAL;
2841 goto out;
2842 }
2843 else if (failifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL)) {
2844 err_code |= ERR_ALERT | ERR_FATAL;
2845 goto out;
2846 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002847
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002848 if ((parse_flags & (SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_PARSE_ADDR)) ==
2849 (SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_PARSE_ADDR)) {
2850 if (!*args[2])
2851 return 0;
2852 }
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002853
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002854 err_code = _srv_parse_init(&newsrv, args, &cur_arg, curproxy,
2855 parse_flags, &errmsg);
2856 if (errmsg) {
2857 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
2858 free(errmsg);
2859 }
Amaury Denoyellecf58dd72021-03-08 16:35:54 +01002860
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002861 /* the servers are linked backwards first */
2862 if (newsrv && !(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
2863 newsrv->next = curproxy->srv;
2864 curproxy->srv = newsrv;
2865 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002866
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002867 if (err_code & ERR_CODE)
2868 goto out;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002869
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002870 newsrv->conf.file = strdup(file);
2871 newsrv->conf.line = linenum;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002872
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002873 while (*args[cur_arg]) {
2874 errmsg = NULL;
2875 err_code = _srv_parse_kw(newsrv, args, &cur_arg, curproxy,
2876 parse_flags, &errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002877
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002878 if (err_code & ERR_ALERT) {
2879 display_parser_err(file, linenum, args, cur_arg, err_code, &errmsg);
2880 free(errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002881 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002882
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002883 if (err_code & ERR_FATAL)
2884 goto out;
2885 }
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002886
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002887 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002888 err_code |= _srv_parse_finalize(args, cur_arg, newsrv, curproxy, parse_flags, &errmsg);
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002889 if (err_code) {
2890 display_parser_err(file, linenum, args, cur_arg, err_code, &errmsg);
2891 free(errmsg);
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002892 }
2893
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002894 if (err_code & ERR_FATAL)
2895 goto out;
Willy Tarreau272adea2014-03-31 10:39:59 +02002896 }
Amaury Denoyellecf58dd72021-03-08 16:35:54 +01002897
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002898 if (parse_flags & SRV_PARSE_TEMPLATE)
2899 _srv_parse_tmpl_init(newsrv, curproxy);
2900
Amaury Denoyellef88af882021-06-08 17:00:20 +02002901 /* If the server id is fixed, insert it in the proxy used_id tree.
2902 * This is needed to detect a later duplicate id via srv_parse_id.
2903 *
2904 * If no is specified, a dynamic one is generated in
2905 * check_config_validity.
2906 */
2907 if (newsrv->flags & SRV_F_FORCED_ID)
2908 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
2909
Amaury Denoyelle24abb0c2021-05-07 15:13:51 +02002910 HA_DIAG_WARNING_COND((curproxy->cap & PR_CAP_LB) && !newsrv->uweight,
Amaury Denoyelleda0e7f62021-03-30 10:26:27 +02002911 "parsing [%s:%d] : 'server %s' : configured with weight of 0 will never be selected by load balancing algorithms\n",
2912 file, linenum, newsrv->id);
2913
Willy Tarreau272adea2014-03-31 10:39:59 +02002914 return 0;
2915
2916 out:
Willy Tarreau272adea2014-03-31 10:39:59 +02002917 return err_code;
2918}
2919
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002920/* Returns a pointer to the first server matching either id <id>.
2921 * NULL is returned if no match is found.
2922 * the lookup is performed in the backend <bk>
2923 */
2924struct server *server_find_by_id(struct proxy *bk, int id)
2925{
2926 struct eb32_node *eb32;
2927 struct server *curserver;
2928
2929 if (!bk || (id ==0))
2930 return NULL;
2931
2932 /* <bk> has no backend capabilities, so it can't have a server */
2933 if (!(bk->cap & PR_CAP_BE))
2934 return NULL;
2935
2936 curserver = NULL;
2937
2938 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2939 if (eb32)
2940 curserver = container_of(eb32, struct server, conf.id);
2941
2942 return curserver;
2943}
2944
2945/* Returns a pointer to the first server matching either name <name>, or id
2946 * if <name> starts with a '#'. NULL is returned if no match is found.
2947 * the lookup is performed in the backend <bk>
2948 */
2949struct server *server_find_by_name(struct proxy *bk, const char *name)
2950{
2951 struct server *curserver;
2952
2953 if (!bk || !name)
2954 return NULL;
2955
2956 /* <bk> has no backend capabilities, so it can't have a server */
2957 if (!(bk->cap & PR_CAP_BE))
2958 return NULL;
2959
2960 curserver = NULL;
2961 if (*name == '#') {
2962 curserver = server_find_by_id(bk, atoi(name + 1));
2963 if (curserver)
2964 return curserver;
2965 }
2966 else {
2967 curserver = bk->srv;
2968
2969 while (curserver && (strcmp(curserver->id, name) != 0))
2970 curserver = curserver->next;
2971
2972 if (curserver)
2973 return curserver;
2974 }
2975
2976 return NULL;
2977}
2978
2979struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2980{
2981 struct server *byname;
2982 struct server *byid;
2983
2984 if (!name && !id)
2985 return NULL;
2986
2987 if (diff)
2988 *diff = 0;
2989
2990 byname = byid = NULL;
2991
2992 if (name) {
2993 byname = server_find_by_name(bk, name);
2994 if (byname && (!id || byname->puid == id))
2995 return byname;
2996 }
2997
2998 /* remaining possibilities :
2999 * - name not set
3000 * - name set but not found
3001 * - name found but ID doesn't match
3002 */
3003 if (id) {
3004 byid = server_find_by_id(bk, id);
3005 if (byid) {
3006 if (byname) {
3007 /* use id only if forced by configuration */
3008 if (byid->flags & SRV_F_FORCED_ID) {
3009 if (diff)
3010 *diff |= 2;
3011 return byid;
3012 }
3013 else {
3014 if (diff)
3015 *diff |= 1;
3016 return byname;
3017 }
3018 }
3019
3020 /* remaining possibilities:
3021 * - name not set
3022 * - name set but not found
3023 */
3024 if (name && diff)
3025 *diff |= 2;
3026 return byid;
3027 }
3028
3029 /* id bot found */
3030 if (byname) {
3031 if (diff)
3032 *diff |= 1;
3033 return byname;
3034 }
3035 }
3036
3037 return NULL;
3038}
3039
Simon Horman7d09b9a2013-02-12 10:45:51 +09003040/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02003041 * update a server's current IP address.
3042 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
3043 * ip is in network format.
3044 * updater is a string which contains an information about the requester of the update.
3045 * updater is used if not NULL.
3046 *
3047 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003048 *
3049 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02003050 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003051int srv_update_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02003052{
Christopher Fauletd6c6b5f2020-09-08 10:27:24 +02003053 /* save the new IP family & address if necessary */
3054 switch (ip_sin_family) {
3055 case AF_INET:
3056 if (s->addr.ss_family == ip_sin_family &&
3057 !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
3058 return 0;
3059 break;
3060 case AF_INET6:
3061 if (s->addr.ss_family == ip_sin_family &&
3062 !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
3063 return 0;
3064 break;
3065 };
3066
Baptiste Assmann14e40142015-04-14 01:13:07 +02003067 /* generates a log line and a warning on stderr */
3068 if (1) {
3069 /* book enough space for both IPv4 and IPv6 */
3070 char oldip[INET6_ADDRSTRLEN];
3071 char newip[INET6_ADDRSTRLEN];
3072
3073 memset(oldip, '\0', INET6_ADDRSTRLEN);
3074 memset(newip, '\0', INET6_ADDRSTRLEN);
3075
3076 /* copy old IP address in a string */
3077 switch (s->addr.ss_family) {
3078 case AF_INET:
3079 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
3080 break;
3081 case AF_INET6:
3082 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
3083 break;
Christopher Fauletb0b76072020-09-08 10:38:40 +02003084 default:
3085 strcpy(oldip, "(none)");
3086 break;
Baptiste Assmann14e40142015-04-14 01:13:07 +02003087 };
3088
3089 /* copy new IP address in a string */
3090 switch (ip_sin_family) {
3091 case AF_INET:
3092 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
3093 break;
3094 case AF_INET6:
3095 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
3096 break;
3097 };
3098
3099 /* save log line into a buffer */
3100 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
3101 s->proxy->id, s->id, oldip, newip, updater);
3102
3103 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003104 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003105
3106 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003107 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003108 }
3109
3110 /* save the new IP family */
3111 s->addr.ss_family = ip_sin_family;
3112 /* save the new IP address */
3113 switch (ip_sin_family) {
3114 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02003115 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003116 break;
3117 case AF_INET6:
3118 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
3119 break;
3120 };
Olivier Houchard4e694042017-03-14 20:01:29 +01003121 srv_set_dyncookie(s);
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02003122 srv_set_addr_desc(s, 1);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003123
3124 return 0;
3125}
3126
William Dauchy7cabc062021-02-11 22:51:24 +01003127/* update agent health check address and port
3128 * addr can be ip4/ip6 or a hostname
3129 * if one error occurs, don't apply anything
3130 * must be called with the server lock held.
3131 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003132const char *srv_update_agent_addr_port(struct server *s, const char *addr, const char *port)
William Dauchy7cabc062021-02-11 22:51:24 +01003133{
3134 struct sockaddr_storage sk;
3135 struct buffer *msg;
3136 int new_port;
3137
3138 msg = get_trash_chunk();
3139 chunk_reset(msg);
3140
3141 if (!(s->agent.state & CHK_ST_ENABLED)) {
3142 chunk_strcat(msg, "agent checks are not enabled on this server");
3143 goto out;
3144 }
3145 if (addr) {
3146 memset(&sk, 0, sizeof(struct sockaddr_storage));
3147 if (str2ip(addr, &sk) == NULL) {
3148 chunk_appendf(msg, "invalid addr '%s'", addr);
3149 goto out;
3150 }
3151 }
3152 if (port) {
3153 if (strl2irc(port, strlen(port), &new_port) != 0) {
3154 chunk_appendf(msg, "provided port is not an integer");
3155 goto out;
3156 }
3157 if (new_port < 0 || new_port > 65535) {
3158 chunk_appendf(msg, "provided port is invalid");
3159 goto out;
3160 }
3161 }
3162out:
3163 if (msg->data)
3164 return msg->area;
3165 else {
3166 if (addr)
3167 set_srv_agent_addr(s, &sk);
3168 if (port)
3169 set_srv_agent_port(s, new_port);
3170 }
3171 return NULL;
3172}
3173
William Dauchyb456e1f2021-02-11 22:51:23 +01003174/* update server health check address and port
3175 * addr must be ip4 or ip6, it won't be resolved
3176 * if one error occurs, don't apply anything
3177 * must be called with the server lock held.
3178 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003179const char *srv_update_check_addr_port(struct server *s, const char *addr, const char *port)
William Dauchyb456e1f2021-02-11 22:51:23 +01003180{
3181 struct sockaddr_storage sk;
3182 struct buffer *msg;
3183 int new_port;
3184
3185 msg = get_trash_chunk();
3186 chunk_reset(msg);
3187
3188 if (!(s->check.state & CHK_ST_ENABLED)) {
3189 chunk_strcat(msg, "health checks are not enabled on this server");
3190 goto out;
3191 }
3192 if (addr) {
3193 memset(&sk, 0, sizeof(struct sockaddr_storage));
3194 if (str2ip2(addr, &sk, 0) == NULL) {
3195 chunk_appendf(msg, "invalid addr '%s'", addr);
3196 goto out;
3197 }
3198 }
3199 if (port) {
3200 if (strl2irc(port, strlen(port), &new_port) != 0) {
3201 chunk_appendf(msg, "provided port is not an integer");
3202 goto out;
3203 }
3204 if (new_port < 0 || new_port > 65535) {
3205 chunk_appendf(msg, "provided port is invalid");
3206 goto out;
3207 }
3208 /* prevent the update of port to 0 if MAPPORTS are in use */
3209 if ((s->flags & SRV_F_MAPPORTS) && new_port == 0) {
3210 chunk_appendf(msg, "can't unset 'port' since MAPPORTS is in use");
3211 goto out;
3212 }
3213 }
3214out:
3215 if (msg->data)
3216 return msg->area;
3217 else {
3218 if (addr)
3219 s->check.addr = sk;
3220 if (port)
3221 s->check.port = new_port;
3222 }
3223 return NULL;
3224}
3225
Baptiste Assmann14e40142015-04-14 01:13:07 +02003226/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003227 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3228 *
3229 * Caller can pass its name through <updater> to get it integrated in the response message
3230 * returned by the function.
3231 *
3232 * The function first does the following, in that order:
3233 * - validates the new addr and/or port
3234 * - checks if an update is required (new IP or port is different than current ones)
3235 * - checks the update is allowed:
3236 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3237 * - allow all changes if no CHECKS are configured
3238 * - if CHECK is configured:
3239 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3240 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3241 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02003242 *
3243 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003244 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003245const char *srv_update_addr_port(struct server *s, const char *addr, const char *port, char *updater)
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003246{
3247 struct sockaddr_storage sa;
3248 int ret, port_change_required;
3249 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003250 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02003251 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003252 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003253
3254 msg = get_trash_chunk();
3255 chunk_reset(msg);
3256
3257 if (addr) {
3258 memset(&sa, 0, sizeof(struct sockaddr_storage));
3259 if (str2ip2(addr, &sa, 0) == NULL) {
3260 chunk_printf(msg, "Invalid addr '%s'", addr);
3261 goto out;
3262 }
3263
3264 /* changes are allowed on AF_INET* families only */
3265 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3266 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3267 goto out;
3268 }
3269
3270 /* collecting data currently setup */
3271 memset(current_addr, '\0', sizeof(current_addr));
3272 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3273 /* changes are allowed on AF_INET* families only */
3274 if ((ret != AF_INET) && (ret != AF_INET6)) {
3275 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3276 goto out;
3277 }
3278
3279 /* applying ADDR changes if required and allowed
3280 * ipcmp returns 0 when both ADDR are the same
3281 */
3282 if (ipcmp(&s->addr, &sa) == 0) {
3283 chunk_appendf(msg, "no need to change the addr");
3284 goto port;
3285 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003286 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003287 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003288
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003289 /* update report for caller */
3290 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3291 }
3292
3293 port:
3294 if (port) {
3295 char sign = '\0';
3296 char *endptr;
3297
3298 if (addr)
3299 chunk_appendf(msg, ", ");
3300
3301 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003302 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003303
3304 /* check if PORT change is required */
3305 port_change_required = 0;
3306
3307 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003308 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003309 new_port = strtol(port, &endptr, 10);
3310 if ((errno != 0) || (port == endptr)) {
3311 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3312 goto out;
3313 }
3314
3315 /* check if caller triggers a port mapped or offset */
3316 if (sign == '-' || (sign == '+')) {
3317 /* check if server currently uses port map */
3318 if (!(s->flags & SRV_F_MAPPORTS)) {
3319 /* switch from fixed port to port map mandatorily triggers
3320 * a port change */
3321 port_change_required = 1;
3322 /* check is configured
3323 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3324 * prevent PORT change if check doesn't have it's dedicated port while switching
3325 * to port mapping */
William Dauchy69f118d2021-02-03 22:30:07 +01003326 if (!s->check.port) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003327 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.");
3328 goto out;
3329 }
3330 }
3331 /* we're already using port maps */
3332 else {
3333 port_change_required = current_port != new_port;
3334 }
3335 }
3336 /* fixed port */
3337 else {
3338 port_change_required = current_port != new_port;
3339 }
3340
3341 /* applying PORT changes if required and update response message */
3342 if (port_change_required) {
3343 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003344 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003345 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003346
3347 /* prepare message */
3348 chunk_appendf(msg, "port changed from '");
3349 if (s->flags & SRV_F_MAPPORTS)
3350 chunk_appendf(msg, "+");
3351 chunk_appendf(msg, "%d' to '", current_port);
3352
3353 if (sign == '-') {
3354 s->flags |= SRV_F_MAPPORTS;
3355 chunk_appendf(msg, "%c", sign);
3356 /* just use for result output */
3357 new_port = -new_port;
3358 }
3359 else if (sign == '+') {
3360 s->flags |= SRV_F_MAPPORTS;
3361 chunk_appendf(msg, "%c", sign);
3362 }
3363 else {
3364 s->flags &= ~SRV_F_MAPPORTS;
3365 }
3366
3367 chunk_appendf(msg, "%d'", new_port);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003368 }
3369 else {
3370 chunk_appendf(msg, "no need to change the port");
3371 }
3372 }
3373
3374out:
William Dauchy6318d332020-05-02 21:52:36 +02003375 if (changed) {
3376 /* force connection cleanup on the given server */
3377 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01003378 srv_set_dyncookie(s);
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02003379 srv_set_addr_desc(s, 1);
William Dauchy6318d332020-05-02 21:52:36 +02003380 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003381 if (updater)
3382 chunk_appendf(msg, " by '%s'", updater);
3383 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003384 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003385}
3386
Christopher Faulet5efdef22021-03-11 18:03:21 +01003387/*
3388 * update server status based on result of SRV resolution
3389 * returns:
3390 * 0 if server status is updated
3391 * 1 if server status has not changed
3392 *
3393 * Must be called with the server lock held.
3394 */
3395int srvrq_update_srv_status(struct server *s, int has_no_ip)
3396{
3397 if (!s->srvrq)
3398 return 1;
3399
3400 /* since this server has an IP, it can go back in production */
3401 if (has_no_ip == 0) {
3402 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3403 return 1;
3404 }
3405
3406 if (s->next_admin & SRV_ADMF_RMAINT)
3407 return 1;
3408
3409 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
3410 return 0;
3411}
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003412
3413/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003414 * update server status based on result of name resolution
3415 * returns:
3416 * 0 if server status is updated
3417 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003418 *
3419 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003420 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003421int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003422{
Emeric Brun750fe792020-12-23 16:51:12 +01003423 struct resolvers *resolvers = s->resolvers;
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003424 struct resolv_resolution *resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003425 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003426
Jerome Magnin012261a2020-07-28 13:38:22 +02003427 /* If resolution is NULL we're dealing with SRV records Additional records */
Christopher Faulet5efdef22021-03-11 18:03:21 +01003428 if (resolution == NULL)
3429 return srvrq_update_srv_status(s, has_no_ip);
Jerome Magnin012261a2020-07-28 13:38:22 +02003430
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003431 switch (resolution->status) {
3432 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003433 /* status when HAProxy has just (re)started.
3434 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003435 break;
3436
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003437 case RSLV_STATUS_VALID:
3438 /*
3439 * resume health checks
3440 * server will be turned back on if health check is safe
3441 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003442 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003443 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003444 return 1;
3445 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3446 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003447 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003448 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003449
Emeric Brun52a91d32017-08-31 14:41:55 +02003450 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003451 return 1;
3452 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3453 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3454 s->proxy->id, s->id);
3455
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003456 ha_warning("%s.\n", trash.area);
3457 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003458 return 0;
3459
3460 case RSLV_STATUS_NX:
3461 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003462 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3463 if (!tick_is_expired(exp, now_ms))
3464 break;
3465
3466 if (s->next_admin & SRV_ADMF_RMAINT)
3467 return 1;
3468 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3469 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003470
3471 case RSLV_STATUS_TIMEOUT:
3472 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003473 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3474 if (!tick_is_expired(exp, now_ms))
3475 break;
3476
3477 if (s->next_admin & SRV_ADMF_RMAINT)
3478 return 1;
3479 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3480 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003481
3482 case RSLV_STATUS_REFUSED:
3483 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003484 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3485 if (!tick_is_expired(exp, now_ms))
3486 break;
3487
3488 if (s->next_admin & SRV_ADMF_RMAINT)
3489 return 1;
3490 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3491 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003492
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003493 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003494 /* stop server if resolution failed for a long enough period */
3495 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3496 if (!tick_is_expired(exp, now_ms))
3497 break;
3498
3499 if (s->next_admin & SRV_ADMF_RMAINT)
3500 return 1;
3501 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3502 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003503 }
3504
3505 return 1;
3506}
3507
3508/*
3509 * Server Name Resolution valid response callback
3510 * It expects:
3511 * - <nameserver>: the name server which answered the valid response
3512 * - <response>: buffer containing a valid DNS response
3513 * - <response_len>: size of <response>
3514 * It performs the following actions:
3515 * - ignore response if current ip found and server family not met
3516 * - update with first new ip found if family is met and current IP is not found
3517 * returns:
3518 * 0 on error
3519 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003520 *
3521 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003522 */
Emeric Brun08622d32020-12-23 17:41:43 +01003523int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *counters)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003524{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003525 struct server *s = NULL;
Emeric Brun08622d32020-12-23 17:41:43 +01003526 struct resolv_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003527 void *serverip, *firstip;
3528 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003529 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003530 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003531 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003532
Christopher Faulet67957bd2017-09-27 11:00:59 +02003533 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003534 if (!s)
3535 return 1;
3536
Christopher Faulet49531e82021-03-10 15:07:27 +01003537 if (s->srvrq) {
Emeric Brun0c4a8a32021-06-11 10:48:45 +02003538 /* If DNS resolution is disabled ignore it.
3539 * This is the case if the server was associated to
3540 * a SRV record and this record is now expired.
Christopher Faulet49531e82021-03-10 15:07:27 +01003541 */
Emeric Brun0c4a8a32021-06-11 10:48:45 +02003542 if (s->flags & SRV_F_NO_RESOLUTION)
Christopher Faulet49531e82021-03-10 15:07:27 +01003543 return 1;
3544 }
3545
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003546 resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
Christopher Faulet49531e82021-03-10 15:07:27 +01003547 if (!resolution)
3548 return 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003549
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003550 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003551 firstip = NULL; /* pointer to the first valid response found */
3552 /* it will be used as the new IP if a change is required */
3553 firstip_sin_family = AF_UNSPEC;
3554 serverip = NULL; /* current server IP address */
3555
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003556 /* initializing server IP pointer */
3557 server_sin_family = s->addr.ss_family;
3558 switch (server_sin_family) {
3559 case AF_INET:
3560 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3561 break;
3562
3563 case AF_INET6:
3564 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3565 break;
3566
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003567 case AF_UNSPEC:
3568 break;
3569
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003570 default:
3571 goto invalid;
3572 }
3573
Emeric Brund30e9a12020-12-23 18:49:16 +01003574 ret = resolv_get_ip_from_response(&resolution->response, &s->resolv_opts,
3575 serverip, server_sin_family, &firstip,
3576 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003577
3578 switch (ret) {
Emeric Brun456de772020-12-23 18:17:31 +01003579 case RSLV_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003580 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003581
Emeric Brun456de772020-12-23 18:17:31 +01003582 case RSLV_UPD_SRVIP_NOT_FOUND:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003583 goto save_ip;
3584
Emeric Brun456de772020-12-23 18:17:31 +01003585 case RSLV_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003586 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003587 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003588
Emeric Brun456de772020-12-23 18:17:31 +01003589 case RSLV_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003590 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003591 resolution->status = RSLV_STATUS_OTHER;
Christopher Fauletb142fb42021-06-24 15:33:52 +02003592 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003593 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003594
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003595 default:
Christopher Fauletb142fb42021-06-24 15:33:52 +02003596 has_no_ip = 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003597 goto invalid;
3598
3599 }
3600
3601 save_ip:
Emeric Brun50c870e2021-01-04 10:40:46 +01003602 if (counters) {
3603 counters->update++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003604 /* save the first ip we found */
Emeric Brun50c870e2021-01-04 10:40:46 +01003605 chunk_printf(chk, "%s/%s", counters->pid, counters->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003606 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003607 else
3608 chunk_printf(chk, "DNS cache");
Christopher Faulet69beaa92021-02-16 12:07:47 +01003609 srv_update_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003610
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003611 update_status:
Christopher Faulet7c129bb2021-06-24 15:26:03 +02003612 if (!snr_update_srv_status(s, has_no_ip) && has_no_ip)
3613 memset(&s->addr, 0, sizeof(s->addr));
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003614 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003615
3616 invalid:
Emeric Brun50c870e2021-01-04 10:40:46 +01003617 if (counters) {
3618 counters->invalid++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003619 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003620 }
Christopher Fauletb142fb42021-06-24 15:33:52 +02003621 if (!snr_update_srv_status(s, has_no_ip) && has_no_ip)
3622 memset(&s->addr, 0, sizeof(s->addr));
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003623 return 0;
3624}
3625
3626/*
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003627 * SRV record error management callback
3628 * returns:
Emeric Brun43839d02021-06-10 15:25:25 +02003629 * 0 if we can trash answser items.
3630 * 1 when safely ignored and we must kept answer items
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003631 *
3632 * Grabs the server's lock.
3633 */
3634int srvrq_resolution_error_cb(struct resolv_requester *requester, int error_code)
3635{
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003636 struct resolv_srvrq *srvrq;
3637 struct resolv_resolution *res;
3638 struct resolvers *resolvers;
3639 int exp;
3640
3641 /* SRV records */
3642 srvrq = objt_resolv_srvrq(requester->owner);
3643 if (!srvrq)
Emeric Brun43839d02021-06-10 15:25:25 +02003644 return 0;
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003645
3646 resolvers = srvrq->resolvers;
3647 res = requester->resolution;
3648
3649 switch (res->status) {
3650
3651 case RSLV_STATUS_NX:
3652 /* stop server if resolution is NX for a long enough period */
3653 exp = tick_add(res->last_valid, resolvers->hold.nx);
3654 if (!tick_is_expired(exp, now_ms))
3655 return 1;
3656 break;
3657
3658 case RSLV_STATUS_TIMEOUT:
3659 /* stop server if resolution is TIMEOUT for a long enough period */
3660 exp = tick_add(res->last_valid, resolvers->hold.timeout);
3661 if (!tick_is_expired(exp, now_ms))
3662 return 1;
3663 break;
3664
3665 case RSLV_STATUS_REFUSED:
3666 /* stop server if resolution is REFUSED for a long enough period */
3667 exp = tick_add(res->last_valid, resolvers->hold.refused);
3668 if (!tick_is_expired(exp, now_ms))
3669 return 1;
3670 break;
3671
3672 default:
3673 /* stop server if resolution failed for a long enough period */
3674 exp = tick_add(res->last_valid, resolvers->hold.other);
3675 if (!tick_is_expired(exp, now_ms))
3676 return 1;
3677 }
3678
Emeric Brun0c4a8a32021-06-11 10:48:45 +02003679 /* Remove any associated server ref */
Willy Tarreau33360872021-10-20 14:07:31 +02003680 resolv_detach_from_resolution_answer_items(res, requester);
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003681
Emeric Brun43839d02021-06-10 15:25:25 +02003682 return 0;
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003683}
3684
3685/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003686 * Server Name Resolution error management callback
3687 * returns:
Emeric Brun43839d02021-06-10 15:25:25 +02003688 * 0 if we can trash answser items.
3689 * 1 when safely ignored and we must kept answer items
Willy Tarreau46b7f532018-08-21 11:54:26 +02003690 *
3691 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003692 */
Emeric Brun08622d32020-12-23 17:41:43 +01003693int snr_resolution_error_cb(struct resolv_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003694{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003695 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003696
Christopher Faulet67957bd2017-09-27 11:00:59 +02003697 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003698 if (!s)
Emeric Brun43839d02021-06-10 15:25:25 +02003699 return 0;
3700
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003701 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Emeric Brun43839d02021-06-10 15:25:25 +02003702 if (!snr_update_srv_status(s, 1)) {
Christopher Faulet5130c212021-03-10 20:31:40 +01003703 memset(&s->addr, 0, sizeof(s->addr));
Emeric Brun43839d02021-06-10 15:25:25 +02003704 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Willy Tarreau33360872021-10-20 14:07:31 +02003705 resolv_detach_from_resolution_answer_items(requester->resolution, requester);
Emeric Brun43839d02021-06-10 15:25:25 +02003706 return 0;
3707 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003708 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Emeric Brun43839d02021-06-10 15:25:25 +02003709
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003710 return 1;
3711}
3712
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003713/*
3714 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003715 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003716 * It returns a pointer to the first server found or NULL if <ip> is not yet
3717 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003718 *
3719 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003720 */
3721struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3722{
3723 struct server *tmpsrv;
3724 struct proxy *be;
3725
3726 if (!srv)
3727 return NULL;
3728
3729 be = srv->proxy;
3730 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003731 /* we found the current server is the same, ignore it */
3732 if (srv == tmpsrv)
3733 continue;
3734
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003735 /* We want to compare the IP in the record with the IP of the servers in the
3736 * same backend, only if:
3737 * * DNS resolution is enabled on the server
3738 * * the hostname used for the resolution by our server is the same than the
3739 * one used for the server found in the backend
3740 * * the server found in the backend is not our current server
3741 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003742 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003743 if ((tmpsrv->hostname_dn == NULL) ||
3744 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
Christopher Faulet59b29252021-03-16 11:21:04 +01003745 (strcasecmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01003746 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003747 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003748 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003749 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003750
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003751 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01003752 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003753 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003754 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003755 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003756
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003757 /* At this point, we have 2 different servers using the same DNS hostname
3758 * for their respective resolution.
3759 */
3760 if (*ip_family == tmpsrv->addr.ss_family &&
3761 ((tmpsrv->addr.ss_family == AF_INET &&
3762 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3763 (tmpsrv->addr.ss_family == AF_INET6 &&
3764 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003765 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003766 return tmpsrv;
3767 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003768 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003769 }
3770
Emeric Brune9fd6b52017-11-02 17:20:39 +01003771
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003772 return NULL;
3773}
3774
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003775/* Sets the server's address (srv->addr) from srv->hostname using the libc's
3776 * resolver. This is suited for initial address configuration. Returns 0 on
3777 * success otherwise a non-zero error code. In case of error, *err_code, if
3778 * not NULL, is filled up.
3779 */
3780int srv_set_addr_via_libc(struct server *srv, int *err_code)
3781{
3782 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003783 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01003784 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003785 return 1;
3786 }
3787 return 0;
3788}
3789
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003790/* Set the server's FDQN (->hostname) from <hostname>.
3791 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003792 *
3793 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003794 */
Emeric Brun08622d32020-12-23 17:41:43 +01003795int srv_set_fqdn(struct server *srv, const char *hostname, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003796{
Emeric Brun08622d32020-12-23 17:41:43 +01003797 struct resolv_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003798 char *hostname_dn;
3799 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003800
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02003801 /* Note that the server lock is already held. */
3802 if (!srv->resolvers)
3803 return -1;
3804
Emeric Brun08622d32020-12-23 17:41:43 +01003805 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003806 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003807 /* run time DNS/SRV resolution was not active for this server
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003808 * and we can't enable it at run time for now.
3809 */
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003810 if (!srv->resolv_requester && !srv->srvrq)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003811 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003812
3813 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003814 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003815 hostname_dn = trash.area;
Willy Tarreauc1c765f2021-10-14 07:49:49 +02003816 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len,
Emeric Brund30e9a12020-12-23 18:49:16 +01003817 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003818 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003819 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003820
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003821 resolution = (srv->resolv_requester ? srv->resolv_requester->resolution : NULL);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003822 if (resolution &&
3823 resolution->hostname_dn &&
Christopher Faulet59b29252021-03-16 11:21:04 +01003824 resolution->hostname_dn_len == hostname_dn_len &&
3825 strcasecmp(resolution->hostname_dn, hostname_dn) == 0)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003826 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003827
Willy Tarreau33360872021-10-20 14:07:31 +02003828 resolv_unlink_resolution(srv->resolv_requester);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003829
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003830 free(srv->hostname);
3831 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003832 srv->hostname = strdup(hostname);
3833 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003834 srv->hostname_dn_len = hostname_dn_len;
3835 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003836 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003837
Baptiste Assmann13a92322019-06-07 09:40:55 +02003838 if (srv->flags & SRV_F_NO_RESOLUTION)
3839 goto end;
3840
Emeric Brund30e9a12020-12-23 18:49:16 +01003841 if (resolv_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003842 goto err;
3843
3844 end:
Emeric Brun08622d32020-12-23 17:41:43 +01003845 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003846 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003847 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02003848
3849 err:
Emeric Brun08622d32020-12-23 17:41:43 +01003850 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003851 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02003852 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003853}
3854
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003855/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
3856 * from the state file. This is suited for initial address configuration.
3857 * Returns 0 on success otherwise a non-zero error code. In case of error,
3858 * *err_code, if not NULL, is filled up.
3859 */
3860static int srv_apply_lastaddr(struct server *srv, int *err_code)
3861{
3862 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
3863 if (err_code)
3864 *err_code |= ERR_WARN;
3865 return 1;
3866 }
3867 return 0;
3868}
3869
Willy Tarreau25e51522016-11-04 15:10:17 +01003870/* returns 0 if no error, otherwise a combination of ERR_* flags */
3871static int srv_iterate_initaddr(struct server *srv)
3872{
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003873 char *name = srv->hostname;
Willy Tarreau25e51522016-11-04 15:10:17 +01003874 int return_code = 0;
3875 int err_code;
3876 unsigned int methods;
3877
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003878 /* If no addr and no hostname set, get the name from the DNS SRV request */
3879 if (!name && srv->srvrq)
3880 name = srv->srvrq->name;
3881
Willy Tarreau25e51522016-11-04 15:10:17 +01003882 methods = srv->init_addr_methods;
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003883 if (!methods) {
3884 /* otherwise default to "last,libc" */
Willy Tarreau25e51522016-11-04 15:10:17 +01003885 srv_append_initaddr(&methods, SRV_IADDR_LAST);
3886 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003887 if (srv->resolvers_id) {
3888 /* dns resolution is configured, add "none" to not fail on startup */
3889 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3890 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003891 }
3892
Willy Tarreau3eed10e2016-11-07 21:03:16 +01003893 /* "-dr" : always append "none" so that server addresses resolution
3894 * failures are silently ignored, this is convenient to validate some
3895 * configs out of their environment.
3896 */
3897 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
3898 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3899
Willy Tarreau25e51522016-11-04 15:10:17 +01003900 while (methods) {
3901 err_code = 0;
3902 switch (srv_get_next_initaddr(&methods)) {
3903 case SRV_IADDR_LAST:
3904 if (!srv->lastaddr)
3905 continue;
3906 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003907 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003908 return_code |= err_code;
3909 break;
3910
3911 case SRV_IADDR_LIBC:
3912 if (!srv->hostname)
3913 continue;
3914 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003915 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003916 return_code |= err_code;
3917 break;
3918
Willy Tarreau37ebe122016-11-04 15:17:58 +01003919 case SRV_IADDR_NONE:
3920 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003921 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003922 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003923 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003924 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01003925 return return_code;
3926
Willy Tarreau4310d362016-11-02 15:05:56 +01003927 case SRV_IADDR_IP:
3928 ipcpy(&srv->init_addr, &srv->addr);
3929 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003930 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 +01003931 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau4310d362016-11-02 15:05:56 +01003932 }
Olivier Houchard4e694042017-03-14 20:01:29 +01003933 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01003934
Willy Tarreau25e51522016-11-04 15:10:17 +01003935 default: /* unhandled method */
3936 break;
3937 }
3938 }
3939
3940 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003941 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003942 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau25e51522016-11-04 15:10:17 +01003943 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01003944 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003945 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003946 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003947 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003948
3949 return_code |= ERR_ALERT | ERR_FATAL;
3950 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01003951out:
3952 srv_set_dyncookie(srv);
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02003953 srv_set_addr_desc(srv, 1);
Olivier Houchard4e694042017-03-14 20:01:29 +01003954 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01003955}
3956
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003957/*
3958 * This function parses all backends and all servers within each backend
3959 * and performs servers' addr resolution based on information provided by:
3960 * - configuration file
3961 * - server-state file (states provided by an 'old' haproxy process)
3962 *
3963 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
3964 */
3965int srv_init_addr(void)
3966{
3967 struct proxy *curproxy;
3968 int return_code = 0;
3969
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003970 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003971 while (curproxy) {
3972 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003973
3974 /* servers are in backend only */
Amaury Denoyellee3c41922021-01-06 14:28:50 +01003975 if (!(curproxy->cap & PR_CAP_BE) || curproxy->disabled)
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003976 goto srv_init_addr_next;
3977
Willy Tarreau25e51522016-11-04 15:10:17 +01003978 for (srv = curproxy->srv; srv; srv = srv->next)
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003979 if (srv->hostname || srv->srvrq)
Willy Tarreau3d609a72017-09-06 14:22:45 +02003980 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003981
3982 srv_init_addr_next:
3983 curproxy = curproxy->next;
3984 }
3985
3986 return return_code;
3987}
3988
Willy Tarreau46b7f532018-08-21 11:54:26 +02003989/*
3990 * Must be called with the server lock held.
3991 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003992const 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 +02003993{
3994
Willy Tarreau83061a82018-07-13 11:56:34 +02003995 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003996
3997 msg = get_trash_chunk();
3998 chunk_reset(msg);
3999
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004000 if (server->hostname && strcmp(fqdn, server->hostname) == 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004001 chunk_appendf(msg, "no need to change the FDQN");
4002 goto out;
4003 }
4004
4005 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
4006 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
4007 goto out;
4008 }
4009
4010 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
4011 server->proxy->id, server->id, server->hostname, fqdn);
4012
Emeric Brun08622d32020-12-23 17:41:43 +01004013 if (srv_set_fqdn(server, fqdn, resolv_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004014 chunk_reset(msg);
4015 chunk_appendf(msg, "could not update %s/%s FQDN",
4016 server->proxy->id, server->id);
4017 goto out;
4018 }
4019
4020 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02004021 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004022
4023 out:
4024 if (updater)
4025 chunk_appendf(msg, " by '%s'", updater);
4026 chunk_appendf(msg, "\n");
4027
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004028 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004029}
4030
4031
Willy Tarreau21b069d2016-11-23 17:15:08 +01004032/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
4033 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004034 * 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 +01004035 * used for CLI commands requiring a server name.
4036 * Important: the <arg> is modified to remove the '/'.
4037 */
4038struct server *cli_find_server(struct appctx *appctx, char *arg)
4039{
4040 struct proxy *px;
4041 struct server *sv;
4042 char *line;
4043
4044 /* split "backend/server" and make <line> point to server */
4045 for (line = arg; *line; line++)
4046 if (*line == '/') {
4047 *line++ = '\0';
4048 break;
4049 }
4050
4051 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004052 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004053 return NULL;
4054 }
4055
4056 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004057 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004058 return NULL;
4059 }
4060
Willy Tarreauc3914d42020-09-24 08:39:22 +02004061 if (px->disabled) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004062 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004063 return NULL;
4064 }
4065
4066 return sv;
4067}
4068
William Lallemand222baf22016-11-19 02:00:33 +01004069
Willy Tarreau46b7f532018-08-21 11:54:26 +02004070/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004071static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01004072{
4073 struct server *sv;
4074 const char *warning;
4075
4076 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4077 return 1;
4078
4079 sv = cli_find_server(appctx, args[2]);
4080 if (!sv)
4081 return 1;
4082
4083 if (strcmp(args[3], "weight") == 0) {
Christopher Faulet77df12c2021-06-15 12:01:29 +02004084 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004085 warning = server_parse_weight_change_request(sv, args[4]);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004086 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02004087 if (warning)
4088 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004089 }
4090 else if (strcmp(args[3], "state") == 0) {
Christopher Faulet77df12c2021-06-15 12:01:29 +02004091 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004092 if (strcmp(args[4], "ready") == 0)
4093 srv_adm_set_ready(sv);
4094 else if (strcmp(args[4], "drain") == 0)
4095 srv_adm_set_drain(sv);
4096 else if (strcmp(args[4], "maint") == 0)
4097 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02004098 else
4099 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004100 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004101 }
4102 else if (strcmp(args[3], "health") == 0) {
Christopher Faulet77df12c2021-06-15 12:01:29 +02004103 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02004104 if (sv->track)
4105 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004106 else if (strcmp(args[4], "up") == 0) {
4107 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004108 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004109 }
4110 else if (strcmp(args[4], "stopping") == 0) {
4111 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004112 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004113 }
4114 else if (strcmp(args[4], "down") == 0) {
4115 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004116 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004117 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004118 else
4119 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004120 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004121 }
4122 else if (strcmp(args[3], "agent") == 0) {
Christopher Faulet77df12c2021-06-15 12:01:29 +02004123 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02004124 if (!(sv->agent.state & CHK_ST_ENABLED))
4125 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004126 else if (strcmp(args[4], "up") == 0) {
4127 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004128 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004129 }
4130 else if (strcmp(args[4], "down") == 0) {
4131 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004132 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004133 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004134 else
4135 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004136 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004137 }
Misiek2da082d2017-01-09 09:40:42 +01004138 else if (strcmp(args[3], "agent-addr") == 0) {
William Dauchy7cabc062021-02-11 22:51:24 +01004139 char *addr = NULL;
4140 char *port = NULL;
4141 if (strlen(args[4]) == 0) {
4142 cli_err(appctx, "set server <b>/<s> agent-addr requires"
4143 " an address and optionally a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004144 goto out;
William Dauchy7cabc062021-02-11 22:51:24 +01004145 }
4146 addr = args[4];
4147 if (strcmp(args[5], "port") == 0)
4148 port = args[6];
Christopher Faulet77df12c2021-06-15 12:01:29 +02004149 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004150 warning = srv_update_agent_addr_port(sv, addr, port);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004151 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchy7cabc062021-02-11 22:51:24 +01004152 if (warning)
4153 cli_msg(appctx, LOG_WARNING, warning);
4154 }
4155 else if (strcmp(args[3], "agent-port") == 0) {
4156 char *port = NULL;
4157 if (strlen(args[4]) == 0) {
4158 cli_err(appctx, "set server <b>/<s> agent-port requires"
4159 " a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004160 goto out;
William Dauchy7cabc062021-02-11 22:51:24 +01004161 }
4162 port = args[4];
Christopher Faulet77df12c2021-06-15 12:01:29 +02004163 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004164 warning = srv_update_agent_addr_port(sv, NULL, port);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004165 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchy7cabc062021-02-11 22:51:24 +01004166 if (warning)
4167 cli_msg(appctx, LOG_WARNING, warning);
Misiek2da082d2017-01-09 09:40:42 +01004168 }
4169 else if (strcmp(args[3], "agent-send") == 0) {
Christopher Faulet88fca372021-06-18 08:47:14 +02004170 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02004171 if (!(sv->agent.state & CHK_ST_ENABLED))
4172 cli_err(appctx, "agent checks are not enabled on this server.\n");
4173 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02004174 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02004175 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01004176 }
Christopher Faulet88fca372021-06-18 08:47:14 +02004177 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Misiek2da082d2017-01-09 09:40:42 +01004178 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004179 else if (strcmp(args[3], "check-addr") == 0) {
4180 char *addr = NULL;
4181 char *port = NULL;
4182 if (strlen(args[4]) == 0) {
4183 cli_err(appctx, "set server <b>/<s> check-addr requires"
4184 " an address and optionally a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004185 goto out;
William Lallemand222baf22016-11-19 02:00:33 +01004186 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004187 addr = args[4];
4188 if (strcmp(args[5], "port") == 0)
4189 port = args[6];
Christopher Faulet77df12c2021-06-15 12:01:29 +02004190 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004191 warning = srv_update_check_addr_port(sv, addr, port);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004192 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchyb456e1f2021-02-11 22:51:23 +01004193 if (warning)
4194 cli_msg(appctx, LOG_WARNING, warning);
4195 }
4196 else if (strcmp(args[3], "check-port") == 0) {
4197 char *port = NULL;
4198 if (strlen(args[4]) == 0) {
4199 cli_err(appctx, "set server <b>/<s> check-port requires"
4200 " a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004201 goto out;
William Lallemand222baf22016-11-19 02:00:33 +01004202 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004203 port = args[4];
Christopher Faulet77df12c2021-06-15 12:01:29 +02004204 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004205 warning = srv_update_check_addr_port(sv, NULL, port);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004206 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchyb456e1f2021-02-11 22:51:23 +01004207 if (warning)
4208 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004209 }
4210 else if (strcmp(args[3], "addr") == 0) {
4211 char *addr = NULL;
4212 char *port = NULL;
4213 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004214 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004215 goto out;
William Lallemand222baf22016-11-19 02:00:33 +01004216 }
4217 else {
4218 addr = args[4];
4219 }
4220 if (strcmp(args[5], "port") == 0) {
4221 port = args[6];
4222 }
Christopher Faulet77df12c2021-06-15 12:01:29 +02004223 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet69beaa92021-02-16 12:07:47 +01004224 warning = srv_update_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02004225 if (warning)
4226 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004227 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004228 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004229 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004230 else if (strcmp(args[3], "fqdn") == 0) {
4231 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004232 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004233 goto out;
4234 }
4235 if (!sv->resolvers) {
4236 cli_err(appctx, "set server <b>/<s> fqdn failed because no resolution is configured.\n");
4237 goto out;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004238 }
Christopher Faulet5b04f462021-06-15 11:37:40 +02004239 if (sv->srvrq) {
4240 cli_err(appctx, "set server <b>/<s> fqdn failed because SRV resolution is configured.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004241 goto out;
Christopher Faulet5b04f462021-06-15 11:37:40 +02004242 }
Christopher Faulet77df12c2021-06-15 12:01:29 +02004243 HA_SPIN_LOCK(DNS_LOCK, &sv->resolvers->lock);
4244 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Baptiste Assmann13a92322019-06-07 09:40:55 +02004245 /* ensure runtime resolver will process this new fqdn */
4246 if (sv->flags & SRV_F_NO_RESOLUTION) {
4247 sv->flags &= ~SRV_F_NO_RESOLUTION;
4248 }
Christopher Faulet77df12c2021-06-15 12:01:29 +02004249 warning = srv_update_fqdn(sv, args[4], "stats socket command", 1);
Christopher Faulet88fca372021-06-18 08:47:14 +02004250 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004251 HA_SPIN_UNLOCK(DNS_LOCK, &sv->resolvers->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +02004252 if (warning)
4253 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004254 }
William Dauchyf6370442020-11-14 19:25:33 +01004255 else if (strcmp(args[3], "ssl") == 0) {
4256#ifdef USE_OPENSSL
4257 if (sv->ssl_ctx.ctx == NULL) {
4258 cli_err(appctx, "'set server <srv> ssl' cannot be set. "
4259 " default-server should define ssl settings\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004260 goto out;
4261 }
4262
4263 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4264 if (strcmp(args[4], "on") == 0) {
William Dauchyf6370442020-11-14 19:25:33 +01004265 ssl_sock_set_srv(sv, 1);
4266 } else if (strcmp(args[4], "off") == 0) {
4267 ssl_sock_set_srv(sv, 0);
4268 } else {
Christopher Faulet77df12c2021-06-15 12:01:29 +02004269 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchyf6370442020-11-14 19:25:33 +01004270 cli_err(appctx, "'set server <srv> ssl' expects 'on' or 'off'.\n");
Christopher Faulet77df12c2021-06-15 12:01:29 +02004271 goto out;
William Dauchyf6370442020-11-14 19:25:33 +01004272 }
4273 srv_cleanup_connections(sv);
Christopher Faulet77df12c2021-06-15 12:01:29 +02004274 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Dauchyf6370442020-11-14 19:25:33 +01004275 cli_msg(appctx, LOG_NOTICE, "server ssl setting updated.\n");
4276#else
4277 cli_msg(appctx, LOG_NOTICE, "server ssl setting not supported.\n");
4278#endif
4279 } else {
Willy Tarreau9d008692019-08-09 11:21:01 +02004280 cli_err(appctx,
William Dauchy3f4ec7d2021-02-15 17:22:16 +01004281 "usage: set server <backend>/<server> "
4282 "addr | agent | agent-addr | agent-port | agent-send | "
4283 "check-addr | check-port | fqdn | health | ssl | "
4284 "state | weight\n");
William Lallemand222baf22016-11-19 02:00:33 +01004285 }
Christopher Faulet77df12c2021-06-15 12:01:29 +02004286 out:
William Lallemand222baf22016-11-19 02:00:33 +01004287 return 1;
4288}
4289
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004290static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004291{
4292 struct stream_interface *si = appctx->owner;
4293 struct proxy *px;
4294 struct server *sv;
4295 char *line;
4296
4297
4298 /* split "backend/server" and make <line> point to server */
4299 for (line = args[2]; *line; line++)
4300 if (*line == '/') {
4301 *line++ = '\0';
4302 break;
4303 }
4304
Willy Tarreau9d008692019-08-09 11:21:01 +02004305 if (!*line)
4306 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004307
Willy Tarreau9d008692019-08-09 11:21:01 +02004308 if (!get_backend_server(args[2], line, &px, &sv))
4309 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004310
4311 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004312 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
4313 sv->iweight);
4314 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004315 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004316 return 0;
4317 }
William Lallemand6b160942016-11-22 12:34:35 +01004318 return 1;
4319}
4320
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004321/* Parse a "set weight" command.
4322 *
4323 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004324 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004325static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004326{
4327 struct server *sv;
4328 const char *warning;
4329
4330 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4331 return 1;
4332
4333 sv = cli_find_server(appctx, args[2]);
4334 if (!sv)
4335 return 1;
4336
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004337 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4338
William Lallemand6b160942016-11-22 12:34:35 +01004339 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004340 if (warning)
4341 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004342
4343 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4344
William Lallemand6b160942016-11-22 12:34:35 +01004345 return 1;
4346}
4347
Willy Tarreau46b7f532018-08-21 11:54:26 +02004348/* parse a "set maxconn server" command. It always returns 1.
4349 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004350 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004351 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004352static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01004353{
4354 struct server *sv;
4355 const char *warning;
4356
4357 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4358 return 1;
4359
4360 sv = cli_find_server(appctx, args[3]);
4361 if (!sv)
4362 return 1;
4363
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02004364 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4365
Willy Tarreaub8026272016-11-23 11:26:56 +01004366 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004367 if (warning)
4368 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004369
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02004370 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4371
Willy Tarreaub8026272016-11-23 11:26:56 +01004372 return 1;
4373}
William Lallemand6b160942016-11-22 12:34:35 +01004374
Willy Tarreau46b7f532018-08-21 11:54:26 +02004375/* parse a "disable agent" command. It always returns 1.
4376 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004377 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004378 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004379static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004380{
4381 struct server *sv;
4382
4383 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4384 return 1;
4385
4386 sv = cli_find_server(appctx, args[2]);
4387 if (!sv)
4388 return 1;
4389
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004390 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004391 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004392 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004393 return 1;
4394}
4395
Willy Tarreau46b7f532018-08-21 11:54:26 +02004396/* parse a "disable health" command. It always returns 1.
4397 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004398 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004399 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004400static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004401{
4402 struct server *sv;
4403
4404 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4405 return 1;
4406
4407 sv = cli_find_server(appctx, args[2]);
4408 if (!sv)
4409 return 1;
4410
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004411 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004412 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004413 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004414 return 1;
4415}
4416
Willy Tarreau46b7f532018-08-21 11:54:26 +02004417/* parse a "disable server" command. It always returns 1.
4418 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004419 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004420 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004421static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004422{
4423 struct server *sv;
4424
4425 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4426 return 1;
4427
4428 sv = cli_find_server(appctx, args[2]);
4429 if (!sv)
4430 return 1;
4431
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004432 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004433 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004434 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004435 return 1;
4436}
4437
Willy Tarreau46b7f532018-08-21 11:54:26 +02004438/* parse a "enable agent" command. It always returns 1.
4439 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004440 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004441 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004442static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004443{
4444 struct server *sv;
4445
4446 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4447 return 1;
4448
4449 sv = cli_find_server(appctx, args[2]);
4450 if (!sv)
4451 return 1;
4452
Willy Tarreau9d008692019-08-09 11:21:01 +02004453 if (!(sv->agent.state & CHK_ST_CONFIGURED))
4454 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004455
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004456 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004457 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004458 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004459 return 1;
4460}
4461
Willy Tarreau46b7f532018-08-21 11:54:26 +02004462/* parse a "enable health" command. It always returns 1.
4463 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004464 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004465 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004466static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004467{
4468 struct server *sv;
4469
4470 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4471 return 1;
4472
4473 sv = cli_find_server(appctx, args[2]);
4474 if (!sv)
4475 return 1;
4476
Amaury Denoyellee636a112021-09-21 10:29:09 +02004477 if (!(sv->check.state & CHK_ST_CONFIGURED))
4478 return cli_err(appctx, "Health check was not configured on this server, cannot enable.\n");
4479
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004480 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004481 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004482 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004483 return 1;
4484}
4485
Willy Tarreau46b7f532018-08-21 11:54:26 +02004486/* parse a "enable server" command. It always returns 1.
4487 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004488 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004489 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004490static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004491{
4492 struct server *sv;
4493
4494 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4495 return 1;
4496
4497 sv = cli_find_server(appctx, args[2]);
4498 if (!sv)
4499 return 1;
4500
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004501 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004502 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004503 if (!(sv->flags & SRV_F_COOKIESET)
4504 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4505 sv->cookie)
4506 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004507 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004508 return 1;
4509}
4510
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004511/* Allocates data structure related to load balancing for the server <sv>. It
4512 * is only required for dynamic servers.
4513 *
4514 * At the moment, the server lock is not used as this function is only called
4515 * for a dynamic server not yet registered.
4516 *
4517 * Returns 1 on success, 0 on allocation failure.
4518 */
4519static int srv_alloc_lb(struct server *sv, struct proxy *be)
4520{
4521 int node;
4522
4523 sv->lb_tree = (sv->flags & SRV_F_BACKUP) ?
4524 &be->lbprm.chash.bck : &be->lbprm.chash.act;
4525 sv->lb_nodes_tot = sv->uweight * BE_WEIGHT_SCALE;
4526 sv->lb_nodes_now = 0;
4527
Willy Tarreaudcb121f2021-04-20 11:37:45 +02004528 if (((be->lbprm.algo & (BE_LB_KIND | BE_LB_PARM)) == (BE_LB_KIND_RR | BE_LB_RR_RANDOM)) ||
4529 ((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 +01004530 sv->lb_nodes = calloc(sv->lb_nodes_tot, sizeof(*sv->lb_nodes));
4531
4532 if (!sv->lb_nodes)
4533 return 0;
4534
4535 for (node = 0; node < sv->lb_nodes_tot; node++) {
4536 sv->lb_nodes[node].server = sv;
4537 sv->lb_nodes[node].node.key = full_hash(sv->puid * SRV_EWGHT_RANGE + node);
4538 }
4539 }
4540
4541 return 1;
4542}
4543
4544/* Parse a "add server" command
4545 * Returns 0 if the server has been successfully initialized, 1 on failure.
4546 */
4547static int cli_parse_add_server(char **args, char *payload, struct appctx *appctx, void *private)
4548{
4549 struct proxy *be;
4550 struct server *srv;
4551 char *be_name, *sv_name;
4552 char *errmsg = NULL;
4553 int errcode, argc;
Amaury Denoyelle12173562021-06-09 09:58:47 +02004554 int next_id, i;
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004555 const int parse_flags = SRV_PARSE_DYNAMIC|SRV_PARSE_PARSE_ADDR;
4556
4557 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4558 return 1;
4559
4560 ++args;
4561
4562 sv_name = be_name = args[1];
4563 /* split backend/server arg */
4564 while (*sv_name && *(++sv_name)) {
4565 if (*sv_name == '/') {
4566 *sv_name = '\0';
4567 ++sv_name;
4568 break;
4569 }
4570 }
4571
4572 if (!*sv_name)
4573 return cli_err(appctx, "Require 'backend/server'.");
4574
Amaury Denoyellecece9182021-04-20 17:09:08 +02004575 be = proxy_be_by_name(be_name);
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004576 if (!be)
4577 return cli_err(appctx, "No such backend.");
4578
4579 if (!(be->lbprm.algo & BE_LB_PROP_DYN)) {
Amaury Denoyelleeafd7012021-04-29 14:59:42 +02004580 cli_err(appctx, "Backend must use a dynamic load balancing to support dynamic servers.");
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004581 return 1;
4582 }
4583
Amaury Denoyelled50d4bf2021-06-10 15:26:44 +02004584 /* At this point, some operations might not be thread-safe anymore. This
4585 * might be the case for parsing handlers which were designed to run
4586 * only at the starting stage on single-thread mode.
4587 *
4588 * Activate thread isolation to ensure thread-safety.
4589 */
4590 thread_isolate();
4591
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004592 args[1] = sv_name;
4593 errcode = _srv_parse_init(&srv, args, &argc, be, parse_flags, &errmsg);
Amaury Denoyellee3c55c22021-08-02 15:50:00 +02004594 if (srv)
4595 srv_use_dynsrv(srv);
4596
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004597 if (errcode) {
4598 if (errmsg)
4599 cli_dynerr(appctx, errmsg);
4600 goto out;
4601 }
4602
4603 while (*args[argc]) {
4604 errcode = _srv_parse_kw(srv, args, &argc, be, parse_flags, &errmsg);
4605
4606 if (errcode) {
4607 if (errmsg)
4608 cli_dynerr(appctx, errmsg);
4609 goto out;
4610 }
4611 }
4612
4613 _srv_parse_finalize(args, argc, srv, be, parse_flags, &errmsg);
4614 if (errmsg) {
4615 cli_dynerr(appctx, errmsg);
4616 goto out;
4617 }
4618
Amaury Denoyellee9bb7fb2021-06-10 17:34:10 +02004619 /* A dynamic server does not currently support resolution.
4620 *
4621 * Initialize it explicitly to the "none" method to ensure no
4622 * resolution will ever be executed.
4623 */
4624 srv->init_addr_methods = SRV_IADDR_NONE;
4625
Amaury Denoyelle30467232021-03-12 18:03:27 +01004626 if (srv->mux_proto) {
4627 if (!conn_get_best_mux_entry(srv->mux_proto->token, PROTO_SIDE_BE, be->mode)) {
4628 cli_err(appctx, "MUX protocol is not usable for server.");
4629 goto out;
4630 }
4631 }
4632
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004633 srv->per_thr = calloc(global.nbthread, sizeof(*srv->per_thr));
4634 if (!srv->per_thr) {
4635 cli_err(appctx, "failed to allocate per-thread lists for server.");
4636 goto out;
4637 }
4638
4639 for (i = 0; i < global.nbthread; i++) {
4640 srv->per_thr[i].idle_conns = EB_ROOT;
4641 srv->per_thr[i].safe_conns = EB_ROOT;
4642 srv->per_thr[i].avail_conns = EB_ROOT;
4643 MT_LIST_INIT(&srv->per_thr[i].streams);
4644 }
4645
4646 if (srv->max_idle_conns != 0) {
4647 srv->curr_idle_thr = calloc(global.nbthread, sizeof(*srv->curr_idle_thr));
4648 if (!srv->curr_idle_thr) {
4649 cli_err(appctx, "failed to allocate counters for server.");
4650 goto out;
4651 }
4652 }
4653
4654 if (!srv_alloc_lb(srv, be)) {
4655 cli_err(appctx, "Failed to initialize load-balancing data.");
4656 goto out;
4657 }
4658
4659 if (!stats_allocate_proxy_counters_internal(&srv->extra_counters,
4660 COUNTERS_SV,
4661 STATS_PX_CAP_SRV)) {
4662 cli_err(appctx, "failed to allocate extra counters for server.");
4663 goto out;
4664 }
4665
Amaury Denoyelled50d4bf2021-06-10 15:26:44 +02004666 /* Attach the server to the end of the proxy linked list. Note that this
4667 * operation is not thread-safe so this is executed under thread
4668 * isolation.
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004669 *
Amaury Denoyelled50d4bf2021-06-10 15:26:44 +02004670 * If a server with the same name is found, reject the new one.
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004671 */
Amaury Denoyellecece9182021-04-20 17:09:08 +02004672
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004673 /* TODO use a double-linked list for px->srv */
4674 if (be->srv) {
Amaury Denoyellecece9182021-04-20 17:09:08 +02004675 struct server *next = be->srv;
4676
4677 while (1) {
4678 /* check for duplicate server */
4679 if (!strcmp(srv->id, next->id)) {
Amaury Denoyellecece9182021-04-20 17:09:08 +02004680 cli_err(appctx, "Already exists a server with the same name in backend.");
4681 goto out;
4682 }
4683
4684 if (!next->next)
4685 break;
4686
4687 next = next->next;
4688 }
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004689
4690 next->next = srv;
4691 }
4692 else {
4693 srv->next = be->srv;
4694 be->srv = srv;
4695 }
Amaury Denoyellecece9182021-04-20 17:09:08 +02004696
Amaury Denoyelle12173562021-06-09 09:58:47 +02004697 /* generate the server id if not manually specified */
4698 if (!srv->puid) {
4699 next_id = get_next_id(&be->conf.used_server_id, 1);
4700 if (!next_id) {
4701 ha_alert("Cannot attach server : no id left in proxy\n");
4702 goto out;
4703 }
4704
4705 srv->conf.id.key = srv->puid = next_id;
Amaury Denoyelle12173562021-06-09 09:58:47 +02004706 }
Christopher Faulet2ea1aa52021-12-07 18:49:44 +01004707 srv->conf.name.key = srv->id;
Amaury Denoyelle12173562021-06-09 09:58:47 +02004708
4709 /* insert the server in the backend trees */
Amaury Denoyellef88af882021-06-08 17:00:20 +02004710 eb32_insert(&be->conf.used_server_id, &srv->conf.id);
4711 ebis_insert(&be->conf.used_server_name, &srv->conf.name);
Amaury Denoyelle2f70bb52021-06-08 15:19:51 +02004712 ebis_insert(&be->used_server_addr, &srv->addr_node);
Amaury Denoyelle12173562021-06-09 09:58:47 +02004713
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004714 thread_release();
4715
Amaury Denoyelled38e7fa2021-04-20 18:35:19 +02004716 ha_notice("New server %s/%s registered.\n", be->id, srv->id);
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004717 cli_msg(appctx, LOG_INFO, "New server registered.");
4718
4719 return 0;
4720
4721out:
Amaury Denoyelledb130872021-08-04 11:20:05 +02004722 if (srv) {
4723 /* remove the server from the proxy linked list */
4724 if (be->srv == srv) {
4725 be->srv = srv->next;
4726 }
4727 else {
4728 struct server *prev;
4729 for (prev = be->srv; prev && prev->next != srv; prev = prev->next)
4730 ;
4731 if (prev)
4732 prev->next = srv->next;
4733 }
4734
4735 }
4736
Amaury Denoyelled50d4bf2021-06-10 15:26:44 +02004737 thread_release();
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004738 if (srv)
4739 free_server(srv);
4740 return 1;
4741}
4742
Amaury Denoyellee5580432021-04-15 14:41:20 +02004743/* Parse a "del server" command
4744 * Returns 0 if the server has been successfully initialized, 1 on failure.
4745 */
4746static int cli_parse_delete_server(char **args, char *payload, struct appctx *appctx, void *private)
4747{
4748 struct proxy *be;
4749 struct server *srv;
4750 char *be_name, *sv_name;
4751
4752 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4753 return 1;
4754
4755 ++args;
4756
4757 sv_name = be_name = args[1];
4758 /* split backend/server arg */
4759 while (*sv_name && *(++sv_name)) {
4760 if (*sv_name == '/') {
4761 *sv_name = '\0';
4762 ++sv_name;
4763 break;
4764 }
4765 }
4766
4767 if (!*sv_name)
4768 return cli_err(appctx, "Require 'backend/server'.");
4769
4770 /* The proxy servers list is currently not protected by a lock so this
4771 * requires thread isolation.
4772 */
4773
4774 /* WARNING there is maybe a potential violation of the thread isolation
4775 * mechanism by the pool allocator. The allocator marks the thread as
4776 * harmless before the allocation, but a processing outside of it could
4777 * relies on a particular server triggered at the same time by a
4778 * 'delete server'. Currently, it is unknown if such case is present in
4779 * the current code. If it happens to be, the thread isolation
4780 * mechanism should be improved, maybe with a differentiation between
4781 * read and read+write safe sections.
4782 */
4783 thread_isolate();
4784
4785 get_backend_server(be_name, sv_name, &be, &srv);
4786 if (!be) {
4787 cli_err(appctx, "No such backend.");
4788 goto out;
4789 }
4790
4791 if (!srv) {
4792 cli_err(appctx, "No such server.");
4793 goto out;
4794 }
4795
4796 if (!(srv->flags & SRV_F_DYNAMIC)) {
4797 cli_err(appctx, "Only servers added at runtime via <add server> CLI cmd can be deleted.");
4798 goto out;
4799 }
4800
4801 /* Only servers in maintenance can be deleted. This ensures that the
4802 * server is not present anymore in the lb structures (through
4803 * lbprm.set_server_status_down).
4804 */
4805 if (!(srv->cur_admin & SRV_ADMF_MAINT)) {
4806 cli_err(appctx, "Only servers in maintenance mode can be deleted.");
4807 goto out;
4808 }
4809
4810 /* Ensure that there is no active/idle/pending connection on the server.
4811 *
4812 * TODO idle connections should not prevent server deletion. A proper
4813 * cleanup function should be implemented to be used here.
4814 */
4815 if (srv->cur_sess || srv->curr_idle_conns ||
4816 !eb_is_empty(&srv->pendconns)) {
4817 cli_err(appctx, "Server still has connections attached to it, cannot remove it.");
4818 goto out;
4819 }
4820
4821 /* TODO remove server for check list once 'check' will be implemented for
4822 * dynamic servers
4823 */
4824
4825 /* detach the server from the proxy linked list
4826 * The proxy servers list is currently not protected by a lock, so this
4827 * requires thread_isolate/release.
4828 */
4829
4830 /* be->srv cannot be empty since we have already found the server with
4831 * get_backend_server */
4832 BUG_ON(!be->srv);
4833 if (be->srv == srv) {
4834 be->srv = srv->next;
4835 }
4836 else {
4837 struct server *next;
Amaury Denoyelled6b4b6d2021-04-21 11:50:26 +02004838 for (next = be->srv; srv != next->next; next = next->next) {
4839 /* srv cannot be not found since we have already found
4840 * it with get_backend_server */
4841 BUG_ON(!next);
4842 }
Amaury Denoyellee5580432021-04-15 14:41:20 +02004843
Amaury Denoyellee5580432021-04-15 14:41:20 +02004844 next->next = srv->next;
4845 }
4846
4847 /* remove srv from addr_node tree */
Amaury Denoyelle40ad9f42021-06-09 16:00:43 +02004848 eb32_delete(&srv->conf.id);
4849 ebpt_delete(&srv->conf.name);
Amaury Denoyellee5580432021-04-15 14:41:20 +02004850 ebpt_delete(&srv->addr_node);
4851
4852 /* remove srv from idle_node tree for idle conn cleanup */
4853 eb32_delete(&srv->idle_node);
4854
4855 thread_release();
4856
4857 ha_notice("Server %s/%s deleted.\n", be->id, srv->id);
4858 free_server(srv);
4859
4860 cli_msg(appctx, LOG_INFO, "Server deleted.");
4861
4862 return 0;
4863
4864out:
4865 thread_release();
4866
4867 return 1;
4868}
4869
William Lallemand222baf22016-11-19 02:00:33 +01004870/* register cli keywords */
4871static struct cli_kw_list cli_kws = {{ },{
Amaury Denoyellec59faa52021-08-03 18:05:37 +02004872 { { "disable", "agent", NULL }, "disable agent : disable agent checks", cli_parse_disable_agent, NULL },
4873 { { "disable", "health", NULL }, "disable health : disable health checks", cli_parse_disable_health, NULL },
Willy Tarreaub205bfd2021-05-07 11:38:37 +02004874 { { "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 +02004875 { { "enable", "agent", NULL }, "enable agent : enable agent checks", cli_parse_enable_agent, NULL },
4876 { { "enable", "health", NULL }, "enable health : enable health checks", cli_parse_enable_health, NULL },
Willy Tarreaub205bfd2021-05-07 11:38:37 +02004877 { { "enable", "server", NULL }, "enable server (DEPRECATED) : enable a disabled server (use 'set server' instead)", cli_parse_enable_server, NULL },
4878 { { "set", "maxconn", "server", NULL }, "set maxconn server <bk>/<srv> : change a server's maxconn setting", cli_parse_set_maxconn_server, NULL },
4879 { { "set", "server", NULL }, "set server <bk>/<srv> [opts] : change a server's state, weight, address or ssl", cli_parse_set_server },
4880 { { "get", "weight", NULL }, "get weight <bk>/<srv> : report a server's current weight", cli_parse_get_weight },
4881 { { "set", "weight", NULL }, "set weight <bk>/<srv> (DEPRECATED) : change a server's weight (use 'set server' instead)", cli_parse_set_weight },
4882 { { "add", "server", NULL }, "add server <bk>/<srv> : create a new server (EXPERIMENTAL)", cli_parse_add_server, NULL, NULL, NULL, ACCESS_EXPERIMENTAL },
4883 { { "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 +01004884 {{},}
4885}};
4886
Willy Tarreau0108d902018-11-25 19:14:37 +01004887INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004888
Emeric Brun64cc49c2017-10-03 14:46:45 +02004889/*
4890 * This function applies server's status changes, it is
4891 * is designed to be called asynchronously.
4892 *
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004893 * Must be called with the server lock held. This may also be called at init
4894 * time as the result of parsing the state file, in which case no lock will be
4895 * held, and the server's warmup task can be null.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004896 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004897static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004898{
4899 struct check *check = &s->check;
4900 int xferred;
4901 struct proxy *px = s->proxy;
4902 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4903 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4904 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004905 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004906
Emeric Brun64cc49c2017-10-03 14:46:45 +02004907 /* If currently main is not set we try to apply pending state changes */
4908 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4909 int next_admin;
4910
4911 /* Backup next admin */
4912 next_admin = s->next_admin;
4913
4914 /* restore current admin state */
4915 s->next_admin = s->cur_admin;
4916
4917 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4918 s->last_change = now.tv_sec;
4919 if (s->proxy->lbprm.set_server_status_down)
4920 s->proxy->lbprm.set_server_status_down(s);
4921
4922 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4923 srv_shutdown_streams(s, SF_ERR_DOWN);
4924
4925 /* we might have streams queued on this server and waiting for
4926 * a connection. Those which are redispatchable will be queued
4927 * to another server or to the proxy itself.
4928 */
4929 xferred = pendconn_redistribute(s);
4930
4931 tmptrash = alloc_trash_chunk();
4932 if (tmptrash) {
4933 chunk_printf(tmptrash,
4934 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4935 s->proxy->id, s->id);
4936
Emeric Brun5a133512017-10-19 14:42:30 +02004937 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004938 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004939
4940 /* we don't send an alert if the server was previously paused */
4941 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004942 send_log(s->proxy, log_level, "%s.\n",
4943 tmptrash->area);
4944 send_email_alert(s, log_level, "%s",
4945 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004946 free_trash_chunk(tmptrash);
4947 tmptrash = NULL;
4948 }
4949 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4950 set_backend_down(s->proxy);
4951
4952 s->counters.down_trans++;
4953 }
4954 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4955 s->last_change = now.tv_sec;
4956 if (s->proxy->lbprm.set_server_status_down)
4957 s->proxy->lbprm.set_server_status_down(s);
4958
4959 /* we might have streams queued on this server and waiting for
4960 * a connection. Those which are redispatchable will be queued
4961 * to another server or to the proxy itself.
4962 */
4963 xferred = pendconn_redistribute(s);
4964
4965 tmptrash = alloc_trash_chunk();
4966 if (tmptrash) {
4967 chunk_printf(tmptrash,
4968 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4969 s->proxy->id, s->id);
4970
Emeric Brun5a133512017-10-19 14:42:30 +02004971 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004972
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004973 ha_warning("%s.\n", tmptrash->area);
4974 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4975 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004976 free_trash_chunk(tmptrash);
4977 tmptrash = NULL;
4978 }
4979
4980 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4981 set_backend_down(s->proxy);
4982 }
4983 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4984 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4985 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4986 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4987 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4988 s->proxy->last_change = now.tv_sec;
4989 }
4990
Amaury Denoyellefe2bf092020-10-29 15:59:04 +01004991 if (s->cur_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
Emeric Brun64cc49c2017-10-03 14:46:45 +02004992 s->down_time += now.tv_sec - s->last_change;
4993
4994 s->last_change = now.tv_sec;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004995 if (s->next_state == SRV_ST_STARTING && s->warmup)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004996 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4997
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004998 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004999 /* now propagate the status change to any LB algorithms */
5000 if (px->lbprm.update_server_eweight)
5001 px->lbprm.update_server_eweight(s);
5002 else if (srv_willbe_usable(s)) {
5003 if (px->lbprm.set_server_status_up)
5004 px->lbprm.set_server_status_up(s);
5005 }
5006 else {
5007 if (px->lbprm.set_server_status_down)
5008 px->lbprm.set_server_status_down(s);
5009 }
5010
5011 /* If the server is set with "on-marked-up shutdown-backup-sessions",
5012 * and it's not a backup server and its effective weight is > 0,
5013 * then it can accept new connections, so we shut down all streams
5014 * on all backup servers.
5015 */
5016 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
5017 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
5018 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
5019
5020 /* check if we can handle some connections queued at the proxy. We
5021 * will take as many as we can handle.
5022 */
5023 xferred = pendconn_grab_from_px(s);
5024
5025 tmptrash = alloc_trash_chunk();
5026 if (tmptrash) {
5027 chunk_printf(tmptrash,
5028 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
5029 s->proxy->id, s->id);
5030
Emeric Brun5a133512017-10-19 14:42:30 +02005031 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005032 ha_warning("%s.\n", tmptrash->area);
5033 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5034 tmptrash->area);
5035 send_email_alert(s, LOG_NOTICE, "%s",
5036 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005037 free_trash_chunk(tmptrash);
5038 tmptrash = NULL;
5039 }
5040
5041 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5042 set_backend_down(s->proxy);
5043 }
5044 else if (s->cur_eweight != s->next_eweight) {
5045 /* now propagate the status change to any LB algorithms */
5046 if (px->lbprm.update_server_eweight)
5047 px->lbprm.update_server_eweight(s);
5048 else if (srv_willbe_usable(s)) {
5049 if (px->lbprm.set_server_status_up)
5050 px->lbprm.set_server_status_up(s);
5051 }
5052 else {
5053 if (px->lbprm.set_server_status_down)
5054 px->lbprm.set_server_status_down(s);
5055 }
5056
5057 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5058 set_backend_down(s->proxy);
5059 }
5060
5061 s->next_admin = next_admin;
5062 }
5063
Emeric Brun5a133512017-10-19 14:42:30 +02005064 /* reset operational state change */
5065 *s->op_st_chg.reason = 0;
5066 s->op_st_chg.status = s->op_st_chg.code = -1;
5067 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005068
5069 /* Now we try to apply pending admin changes */
5070
5071 /* Maintenance must also disable health checks */
5072 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
5073 if (s->check.state & CHK_ST_ENABLED) {
5074 s->check.state |= CHK_ST_PAUSED;
5075 check->health = 0;
5076 }
5077
5078 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02005079 tmptrash = alloc_trash_chunk();
5080 if (tmptrash) {
5081 chunk_printf(tmptrash,
5082 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
5083 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5084 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02005085
Olivier Houchard796a2b32017-10-24 17:42:47 +02005086 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02005087
Olivier Houchard796a2b32017-10-24 17:42:47 +02005088 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005089 ha_warning("%s.\n", tmptrash->area);
5090 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5091 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02005092 }
5093 free_trash_chunk(tmptrash);
5094 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005095 }
Emeric Brun8f298292017-12-06 16:47:17 +01005096 /* commit new admin status */
5097
5098 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005099 }
5100 else { /* server was still running */
5101 check->health = 0; /* failure */
5102 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01005103
5104 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005105 if (s->proxy->lbprm.set_server_status_down)
5106 s->proxy->lbprm.set_server_status_down(s);
5107
Emeric Brun64cc49c2017-10-03 14:46:45 +02005108 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
5109 srv_shutdown_streams(s, SF_ERR_DOWN);
5110
William Dauchy6318d332020-05-02 21:52:36 +02005111 /* force connection cleanup on the given server */
5112 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005113 /* we might have streams queued on this server and waiting for
5114 * a connection. Those which are redispatchable will be queued
5115 * to another server or to the proxy itself.
5116 */
5117 xferred = pendconn_redistribute(s);
5118
5119 tmptrash = alloc_trash_chunk();
5120 if (tmptrash) {
5121 chunk_printf(tmptrash,
5122 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
5123 s->flags & SRV_F_BACKUP ? "Backup " : "",
5124 s->proxy->id, s->id,
5125 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5126
5127 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
5128
5129 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005130 ha_warning("%s.\n", tmptrash->area);
5131 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
5132 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005133 }
5134 free_trash_chunk(tmptrash);
5135 tmptrash = NULL;
5136 }
5137 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5138 set_backend_down(s->proxy);
5139
5140 s->counters.down_trans++;
5141 }
5142 }
5143 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
5144 /* OK here we're leaving maintenance, we have many things to check,
5145 * because the server might possibly be coming back up depending on
5146 * its state. In practice, leaving maintenance means that we should
5147 * immediately turn to UP (more or less the slowstart) under the
5148 * following conditions :
5149 * - server is neither checked nor tracked
5150 * - server tracks another server which is not checked
5151 * - server tracks another server which is already up
5152 * Which sums up as something simpler :
5153 * "either the tracking server is up or the server's checks are disabled
5154 * or up". Otherwise we only re-enable health checks. There's a special
5155 * case associated to the stopping state which can be inherited. Note
5156 * that the server might still be in drain mode, which is naturally dealt
5157 * with by the lower level functions.
5158 */
5159
5160 if (s->check.state & CHK_ST_ENABLED) {
5161 s->check.state &= ~CHK_ST_PAUSED;
5162 check->health = check->rise; /* start OK but check immediately */
5163 }
5164
5165 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
5166 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
5167 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
5168 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
5169 s->next_state = SRV_ST_STOPPING;
5170 }
5171 else {
Willy Tarreauf79c4cf2021-08-04 19:35:13 +02005172 s->last_change = now.tv_sec;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005173 s->next_state = SRV_ST_STARTING;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02005174 if (s->slowstart > 0) {
5175 if (s->warmup)
5176 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
5177 }
Emeric Brun64cc49c2017-10-03 14:46:45 +02005178 else
5179 s->next_state = SRV_ST_RUNNING;
5180 }
5181
5182 }
5183
5184 tmptrash = alloc_trash_chunk();
5185 if (tmptrash) {
5186 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5187 chunk_printf(tmptrash,
5188 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
5189 s->flags & SRV_F_BACKUP ? "Backup " : "",
5190 s->proxy->id, s->id,
5191 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5192 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5193 }
5194 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5195 chunk_printf(tmptrash,
5196 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
5197 s->flags & SRV_F_BACKUP ? "Backup " : "",
5198 s->proxy->id, s->id, s->hostname,
5199 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5200 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5201 }
5202 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5203 chunk_printf(tmptrash,
5204 "%sServer %s/%s is %s/%s (leaving maintenance)",
5205 s->flags & SRV_F_BACKUP ? "Backup " : "",
5206 s->proxy->id, s->id,
5207 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5208 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5209 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005210 ha_warning("%s.\n", tmptrash->area);
5211 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5212 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005213 free_trash_chunk(tmptrash);
5214 tmptrash = NULL;
5215 }
5216
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005217 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005218 /* now propagate the status change to any LB algorithms */
5219 if (px->lbprm.update_server_eweight)
5220 px->lbprm.update_server_eweight(s);
5221 else if (srv_willbe_usable(s)) {
5222 if (px->lbprm.set_server_status_up)
5223 px->lbprm.set_server_status_up(s);
5224 }
5225 else {
5226 if (px->lbprm.set_server_status_down)
5227 px->lbprm.set_server_status_down(s);
5228 }
5229
5230 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5231 set_backend_down(s->proxy);
Willy Tarreauf79c4cf2021-08-04 19:35:13 +02005232 else if (!prev_srv_count && (s->proxy->srv_bck || s->proxy->srv_act))
5233 s->proxy->last_change = now.tv_sec;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005234
Willy Tarreau6a78e612018-08-07 10:14:53 +02005235 /* If the server is set with "on-marked-up shutdown-backup-sessions",
5236 * and it's not a backup server and its effective weight is > 0,
5237 * then it can accept new connections, so we shut down all streams
5238 * on all backup servers.
5239 */
5240 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
5241 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
5242 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
5243
5244 /* check if we can handle some connections queued at the proxy. We
5245 * will take as many as we can handle.
5246 */
5247 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005248 }
5249 else if (s->next_admin & SRV_ADMF_MAINT) {
5250 /* remaining in maintenance mode, let's inform precisely about the
5251 * situation.
5252 */
5253 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5254 tmptrash = alloc_trash_chunk();
5255 if (tmptrash) {
5256 chunk_printf(tmptrash,
5257 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
5258 s->flags & SRV_F_BACKUP ? "Backup " : "",
5259 s->proxy->id, s->id);
5260
5261 if (s->track) /* normally it's mandatory here */
5262 chunk_appendf(tmptrash, " via %s/%s",
5263 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005264 ha_warning("%s.\n", tmptrash->area);
5265 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5266 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005267 free_trash_chunk(tmptrash);
5268 tmptrash = NULL;
5269 }
5270 }
5271 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5272 tmptrash = alloc_trash_chunk();
5273 if (tmptrash) {
5274 chunk_printf(tmptrash,
5275 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
5276 s->flags & SRV_F_BACKUP ? "Backup " : "",
5277 s->proxy->id, s->id, s->hostname);
5278
5279 if (s->track) /* normally it's mandatory here */
5280 chunk_appendf(tmptrash, " via %s/%s",
5281 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005282 ha_warning("%s.\n", tmptrash->area);
5283 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5284 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005285 free_trash_chunk(tmptrash);
5286 tmptrash = NULL;
5287 }
5288 }
5289 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5290 tmptrash = alloc_trash_chunk();
5291 if (tmptrash) {
5292 chunk_printf(tmptrash,
5293 "%sServer %s/%s remains in forced maintenance",
5294 s->flags & SRV_F_BACKUP ? "Backup " : "",
5295 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005296 ha_warning("%s.\n", tmptrash->area);
5297 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5298 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005299 free_trash_chunk(tmptrash);
5300 tmptrash = NULL;
5301 }
5302 }
5303 /* don't report anything when leaving drain mode and remaining in maintenance */
5304
5305 s->cur_admin = s->next_admin;
5306 }
5307
5308 if (!(s->next_admin & SRV_ADMF_MAINT)) {
5309 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
5310 /* drain state is applied only if not yet in maint */
5311
5312 s->last_change = now.tv_sec;
5313 if (px->lbprm.set_server_status_down)
5314 px->lbprm.set_server_status_down(s);
5315
5316 /* we might have streams queued on this server and waiting for
5317 * a connection. Those which are redispatchable will be queued
5318 * to another server or to the proxy itself.
5319 */
5320 xferred = pendconn_redistribute(s);
5321
5322 tmptrash = alloc_trash_chunk();
5323 if (tmptrash) {
5324 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
5325 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5326 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5327
5328 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
5329
5330 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005331 ha_warning("%s.\n", tmptrash->area);
5332 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5333 tmptrash->area);
5334 send_email_alert(s, LOG_NOTICE, "%s",
5335 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005336 }
5337 free_trash_chunk(tmptrash);
5338 tmptrash = NULL;
5339 }
5340
5341 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5342 set_backend_down(s->proxy);
5343 }
5344 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
5345 /* OK completely leaving drain mode */
5346 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
5347 if (s->proxy->last_change < now.tv_sec) // ignore negative times
5348 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
5349 s->proxy->last_change = now.tv_sec;
5350 }
5351
5352 if (s->last_change < now.tv_sec) // ignore negative times
5353 s->down_time += now.tv_sec - s->last_change;
5354 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005355 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005356
5357 tmptrash = alloc_trash_chunk();
5358 if (tmptrash) {
5359 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5360 chunk_printf(tmptrash,
5361 "%sServer %s/%s is %s (leaving forced drain)",
5362 s->flags & SRV_F_BACKUP ? "Backup " : "",
5363 s->proxy->id, s->id,
5364 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5365 }
5366 else {
5367 chunk_printf(tmptrash,
5368 "%sServer %s/%s is %s (leaving drain)",
5369 s->flags & SRV_F_BACKUP ? "Backup " : "",
5370 s->proxy->id, s->id,
5371 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5372 if (s->track) /* normally it's mandatory here */
5373 chunk_appendf(tmptrash, " via %s/%s",
5374 s->track->proxy->id, s->track->id);
5375 }
5376
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005377 ha_warning("%s.\n", tmptrash->area);
5378 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5379 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005380 free_trash_chunk(tmptrash);
5381 tmptrash = NULL;
5382 }
5383
5384 /* now propagate the status change to any LB algorithms */
5385 if (px->lbprm.update_server_eweight)
5386 px->lbprm.update_server_eweight(s);
5387 else if (srv_willbe_usable(s)) {
5388 if (px->lbprm.set_server_status_up)
5389 px->lbprm.set_server_status_up(s);
5390 }
5391 else {
5392 if (px->lbprm.set_server_status_down)
5393 px->lbprm.set_server_status_down(s);
5394 }
5395 }
5396 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
5397 /* remaining in drain mode after removing one of its flags */
5398
5399 tmptrash = alloc_trash_chunk();
5400 if (tmptrash) {
5401 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5402 chunk_printf(tmptrash,
5403 "%sServer %s/%s is leaving forced drain but remains in drain mode",
5404 s->flags & SRV_F_BACKUP ? "Backup " : "",
5405 s->proxy->id, s->id);
5406
5407 if (s->track) /* normally it's mandatory here */
5408 chunk_appendf(tmptrash, " via %s/%s",
5409 s->track->proxy->id, s->track->id);
5410 }
5411 else {
5412 chunk_printf(tmptrash,
5413 "%sServer %s/%s remains in forced drain mode",
5414 s->flags & SRV_F_BACKUP ? "Backup " : "",
5415 s->proxy->id, s->id);
5416 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005417 ha_warning("%s.\n", tmptrash->area);
5418 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5419 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005420 free_trash_chunk(tmptrash);
5421 tmptrash = NULL;
5422 }
5423
5424 /* commit new admin status */
5425
5426 s->cur_admin = s->next_admin;
5427 }
5428 }
5429
5430 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02005431 *s->adm_st_chg_cause = 0;
5432}
Emeric Brun64cc49c2017-10-03 14:46:45 +02005433
Willy Tarreau144f84a2021-03-02 16:09:26 +01005434struct task *srv_cleanup_toremove_conns(struct task *task, void *context, unsigned int state)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005435{
5436 struct connection *conn;
5437
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005438 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005439 struct connection *, toremove_list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02005440 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005441 }
5442
5443 return task;
5444}
5445
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005446/* Move toremove_nb connections from idle_tree to toremove_list, -1 means
Olivier Houchardff1d0922020-06-29 20:15:59 +02005447 * moving them all.
5448 * Returns the number of connections moved.
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005449 *
5450 * Must be called with idle_conns_lock held.
Olivier Houchardff1d0922020-06-29 20:15:59 +02005451 */
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005452static 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 +02005453{
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005454 struct eb_node *node, *next;
Amaury Denoyelle8990b012021-02-19 15:29:16 +01005455 struct conn_hash_node *hash_node;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005456 int i = 0;
5457
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005458 node = eb_first(idle_tree);
5459 while (node) {
5460 next = eb_next(node);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005461 if (toremove_nb != -1 && i >= toremove_nb)
5462 break;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005463
Amaury Denoyelle8990b012021-02-19 15:29:16 +01005464 hash_node = ebmb_entry(node, struct conn_hash_node, node);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005465 eb_delete(node);
Willy Tarreau2b718102021-04-21 07:32:39 +02005466 MT_LIST_APPEND(toremove_list, &hash_node->conn->toremove_list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005467 i++;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005468
5469 node = next;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005470 }
5471 return i;
5472}
William Dauchy6318d332020-05-02 21:52:36 +02005473/* cleanup connections for a given server
5474 * might be useful when going on forced maintenance or live changing ip/port
5475 */
William Dauchy707ad322020-05-04 13:52:40 +02005476static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02005477{
William Dauchy6318d332020-05-02 21:52:36 +02005478 int did_remove;
5479 int i;
William Dauchy6318d332020-05-02 21:52:36 +02005480
Amaury Denoyelle10d5c312021-01-06 14:28:51 +01005481 /* nothing to do if pool-max-conn is null */
5482 if (!srv->max_idle_conns)
5483 return;
5484
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005485 /* check all threads starting with ours */
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005486 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02005487 did_remove = 0;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005488 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005489 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 +02005490 did_remove = 1;
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005491 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 +02005492 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005493 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
William Dauchy6318d332020-05-02 21:52:36 +02005494 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005495 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005496
5497 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5498 break;
William Dauchy6318d332020-05-02 21:52:36 +02005499 }
William Dauchy6318d332020-05-02 21:52:36 +02005500}
5501
Willy Tarreau144f84a2021-03-02 16:09:26 +01005502struct task *srv_cleanup_idle_conns(struct task *task, void *context, unsigned int state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005503{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005504 struct server *srv;
5505 struct eb32_node *eb;
5506 int i;
5507 unsigned int next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005508
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005509 next_wakeup = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005510 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
5511 while (1) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005512 int exceed_conns;
5513 int to_kill;
5514 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005515
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005516 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
5517 if (!eb) {
5518 /* we might have reached the end of the tree, typically because
5519 * <now_ms> is in the first half and we're first scanning the last
5520 * half. Let's loop back to the beginning of the tree now.
5521 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005522
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005523 eb = eb32_first(&idle_conn_srv);
5524 if (likely(!eb))
5525 break;
5526 }
5527 if (tick_is_lt(now_ms, eb->key)) {
5528 /* timer not expired yet, revisit it later */
5529 next_wakeup = eb->key;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005530 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005531 }
5532 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005533
5534 /* Calculate how many idle connections we want to kill :
5535 * we want to remove half the difference between the total
5536 * of established connections (used or idle) and the max
5537 * number of used connections.
5538 */
5539 curr_idle = srv->curr_idle_conns;
5540 if (curr_idle == 0)
5541 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005542 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005543 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005544
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005545 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns) / 2;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005546 if (srv->est_need_conns < srv->max_used_conns)
5547 srv->est_need_conns = srv->max_used_conns;
5548
Willy Tarreau41d57422022-11-21 14:32:33 +01005549 HA_ATOMIC_STORE(&srv->max_used_conns, srv->curr_used_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005550
Willy Tarreau18ed7892020-07-02 19:05:30 +02005551 if (exceed_conns <= 0)
5552 goto remove;
5553
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005554 /* check all threads starting with ours */
5555 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005556 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005557 int j;
5558 int did_remove = 0;
5559
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005560 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
5561 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005562
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005563 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005564 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 +02005565 if (j > 0)
5566 did_remove = 1;
5567 if (max_conn - j > 0 &&
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005568 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 +01005569 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005570 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005571
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005572 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005573 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005574
5575 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5576 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005577 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005578remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005579 eb32_delete(&srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005580
5581 if (srv->curr_idle_conns) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005582 /* There are still more idle connections, add the
5583 * server back in the tree.
5584 */
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005585 srv->idle_node.key = tick_add(srv->pool_purge_delay, now_ms);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005586 eb32_insert(&idle_conn_srv, &srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005587 next_wakeup = tick_first(next_wakeup, srv->idle_node.key);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005588 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005589 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005590 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5591
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005592 task->expire = next_wakeup;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005593 return task;
5594}
Olivier Houchard88698d92019-04-16 19:07:22 +02005595
Amaury Denoyelle3109ccf2021-04-29 17:30:05 +02005596/* Close remaining idle connections. This functions is designed to be run on
5597 * process shutdown. This guarantees a proper socket shutdown to avoid
5598 * TIME_WAIT state. For a quick operation, only ctrl is closed, xprt stack is
5599 * bypassed.
5600 *
5601 * This function is not thread-safe so it must only be called via a global
5602 * deinit function.
5603 */
5604static void srv_close_idle_conns(struct server *srv)
5605{
5606 struct eb_root **cleaned_tree;
5607 int i;
5608
5609 for (i = 0; i < global.nbthread; ++i) {
5610 struct eb_root *conn_trees[] = {
5611 &srv->per_thr[i].idle_conns,
5612 &srv->per_thr[i].safe_conns,
5613 &srv->per_thr[i].avail_conns,
5614 NULL
5615 };
5616
5617 for (cleaned_tree = conn_trees; *cleaned_tree; ++cleaned_tree) {
5618 while (!eb_is_empty(*cleaned_tree)) {
5619 struct ebmb_node *node = ebmb_first(*cleaned_tree);
5620 struct conn_hash_node *conn_hash_node = ebmb_entry(node, struct conn_hash_node, node);
5621 struct connection *conn = conn_hash_node->conn;
5622
5623 if (conn->ctrl->ctrl_close)
5624 conn->ctrl->ctrl_close(conn);
5625 ebmb_delete(node);
5626 }
5627 }
5628 }
5629}
5630
5631REGISTER_SERVER_DEINIT(srv_close_idle_conns);
5632
Willy Tarreau76cc6992020-07-01 18:49:24 +02005633/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
5634static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01005635 const struct proxy *defpx, const char *file, int line,
Willy Tarreau76cc6992020-07-01 18:49:24 +02005636 char **err)
5637{
5638 if (too_many_args(1, args, err, NULL))
5639 return -1;
5640
5641 if (strcmp(args[1], "on") == 0)
5642 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
5643 else if (strcmp(args[1], "off") == 0)
5644 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
5645 else {
5646 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
5647 return -1;
5648 }
5649 return 0;
5650}
5651
Olivier Houchard88698d92019-04-16 19:07:22 +02005652/* config parser for global "tune.pool-{low,high}-fd-ratio" */
5653static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01005654 const struct proxy *defpx, const char *file, int line,
Olivier Houchard88698d92019-04-16 19:07:22 +02005655 char **err)
5656{
5657 int arg = -1;
5658
5659 if (too_many_args(1, args, err, NULL))
5660 return -1;
5661
5662 if (*(args[1]) != 0)
5663 arg = atoi(args[1]);
5664
5665 if (arg < 0 || arg > 100) {
5666 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
5667 return -1;
5668 }
5669
5670 if (args[0][10] == 'h')
5671 global.tune.pool_high_ratio = arg;
5672 else
5673 global.tune.pool_low_ratio = arg;
5674 return 0;
5675}
5676
5677/* config keyword parsers */
5678static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02005679 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02005680 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
5681 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
5682 { 0, NULL, NULL }
5683}};
5684
5685INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
5686
Baptiste Assmanna68ca962015-04-14 01:15:08 +02005687/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02005688 * Local variables:
5689 * c-indent-level: 8
5690 * c-basic-offset: 8
5691 * End:
5692 */