blob: da6ee52ad069f82979317d4f6bd1345e0fd49c57 [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 Tarreaub2551052020-06-09 09:07:15 +020019#include <import/ebsttree.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020020#include <import/xxhash.h>
21
Willy Tarreaub2551052020-06-09 09:07:15 +020022#include <haproxy/api.h>
Willy Tarreau3f0f82e2020-06-04 19:42:41 +020023#include <haproxy/applet-t.h>
Willy Tarreau49801602020-06-04 22:50:02 +020024#include <haproxy/backend.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020025#include <haproxy/cfgparse.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020026#include <haproxy/check.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020027#include <haproxy/cli.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020028#include <haproxy/connection.h>
Willy Tarreau3afc4c42020-06-03 18:23:19 +020029#include <haproxy/dict-t.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020030#include <haproxy/errors.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020031#include <haproxy/global.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020032#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020033#include <haproxy/mailers.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020034#include <haproxy/namespace.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020035#include <haproxy/port_range.h>
36#include <haproxy/protocol.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>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020042#include <haproxy/stats-t.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>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020048
Baptiste Assmannda29fe22019-06-13 13:24:29 +020049
Willy Tarreau3ff577e2018-08-02 11:48:52 +020050static void srv_update_status(struct server *s);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020051static void srv_update_state(struct server *srv, int version, char **params);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010052static int srv_apply_lastaddr(struct server *srv, int *err_code);
Emeric Brun08622d32020-12-23 17:41:43 +010053static int srv_set_fqdn(struct server *srv, const char *fqdn, int resolv_locked);
Baptiste Assmannda29fe22019-06-13 13:24:29 +020054static void srv_state_parse_line(char *buf, const int version, char **params, char **srv_params);
55static int srv_state_get_version(FILE *f);
William Dauchy6318d332020-05-02 21:52:36 +020056static void srv_cleanup_connections(struct server *srv);
William Dauchyb456e1f2021-02-11 22:51:23 +010057static const char *update_server_check_addr_port(struct server *s, const char *addr,
58 const char *port);
William Dauchy7cabc062021-02-11 22:51:24 +010059static const char *update_server_agent_addr_port(struct server *s, const char *addr,
60 const char *port);
Willy Tarreaubaaee002006-06-26 02:48:02 +020061
Willy Tarreau21faa912012-10-10 08:27:36 +020062/* List head of all known server keywords */
63static struct srv_kw_list srv_keywords = {
64 .list = LIST_HEAD_INIT(srv_keywords.list)
65};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020066
Willy Tarreauaf613e82020-06-05 08:40:51 +020067__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010068struct eb_root idle_conn_srv = EB_ROOT;
69struct task *idle_conn_task = NULL;
Olivier Houchard9ea5d362019-02-14 18:29:09 +010070
Frédéric Lécaille7da71292019-05-20 09:47:07 +020071/* The server names dictionary */
Thayne McCombs92149f92020-11-20 01:28:26 -070072struct dict server_key_dict = {
73 .name = "server keys",
Frédéric Lécaille7da71292019-05-20 09:47:07 +020074 .values = EB_ROOT_UNIQUE,
75};
76
Baptiste Assmannda29fe22019-06-13 13:24:29 +020077/* tree where global state_file is loaded */
Willy Tarreaufd1aa012019-12-20 17:23:40 +010078struct eb_root state_file = EB_ROOT_UNIQUE;
Baptiste Assmannda29fe22019-06-13 13:24:29 +020079
Simon Hormana3608442013-11-01 16:46:15 +090080int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020081{
Amaury Denoyellee6ba7912020-10-29 15:59:05 +010082 if ((s->cur_state != SRV_ST_STOPPED) || s->last_change >= now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020083 return s->down_time;
84
85 return now.tv_sec - s->last_change + s->down_time;
86}
Willy Tarreaubaaee002006-06-26 02:48:02 +020087
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050088int srv_lastsession(const struct server *s)
89{
90 if (s->counters.last_sess)
91 return now.tv_sec - s->counters.last_sess;
92
93 return -1;
94}
95
Simon Horman4a741432013-02-23 15:35:38 +090096int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020097{
Simon Horman4a741432013-02-23 15:35:38 +090098 const struct server *s = check->server;
99
Willy Tarreauff5ae352013-12-11 20:36:34 +0100100 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +0900101 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100102
Emeric Brun52a91d32017-08-31 14:41:55 +0200103 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +0900104 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100105
Simon Horman4a741432013-02-23 15:35:38 +0900106 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100107}
108
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100109/*
110 * Check that we did not get a hash collision.
Willy Tarreau595e7672020-10-20 17:30:08 +0200111 * Unlikely, but it can happen. The server's proxy must be at least
112 * read-locked.
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100113 */
114static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +0100115{
116 struct proxy *p = s->proxy;
117 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100118
119 for (tmpserv = p->srv; tmpserv != NULL;
120 tmpserv = tmpserv->next) {
121 if (tmpserv == s)
122 continue;
123 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
124 continue;
125 if (tmpserv->cookie &&
126 strcmp(tmpserv->cookie, s->cookie) == 0) {
127 ha_warning("We generated two equal cookies for two different servers.\n"
128 "Please change the secret key for '%s'.\n",
129 s->proxy->id);
130 }
131 }
132
133}
134
Willy Tarreau46b7f532018-08-21 11:54:26 +0200135/*
Willy Tarreau595e7672020-10-20 17:30:08 +0200136 * Must be called with the server lock held, and will read-lock the proxy.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200137 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100138void srv_set_dyncookie(struct server *s)
139{
140 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100141 char *tmpbuf;
142 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100143 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100144 size_t buffer_len;
145 int addr_len;
146 int port;
147
Willy Tarreau595e7672020-10-20 17:30:08 +0200148 HA_RWLOCK_RDLOCK(PROXY_LOCK, &p->lock);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200149
Olivier Houchard4e694042017-03-14 20:01:29 +0100150 if ((s->flags & SRV_F_COOKIESET) ||
151 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
152 s->proxy->dyncookie_key == NULL)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200153 goto out;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100154 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100155
156 if (s->addr.ss_family != AF_INET &&
157 s->addr.ss_family != AF_INET6)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200158 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100159 /*
160 * Buffer to calculate the cookie value.
161 * The buffer contains the secret key + the server IP address
162 * + the TCP port.
163 */
164 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
165 /*
166 * The TCP port should use only 2 bytes, but is stored in
167 * an unsigned int in struct server, so let's use 4, to be
168 * on the safe side.
169 */
170 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200171 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100172 memcpy(tmpbuf, p->dyncookie_key, key_len);
173 memcpy(&(tmpbuf[key_len]),
174 s->addr.ss_family == AF_INET ?
175 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
176 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
177 addr_len);
178 /*
179 * Make sure it's the same across all the load balancers,
180 * no matter their endianness.
181 */
182 port = htonl(s->svc_port);
183 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
184 hash_value = XXH64(tmpbuf, buffer_len, 0);
185 memprintf(&s->cookie, "%016llx", hash_value);
186 if (!s->cookie)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200187 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100188 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100189
190 /* Don't bother checking if the dyncookie is duplicated if
191 * the server is marked as "disabled", maybe it doesn't have
192 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100193 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100194 if (!(s->next_admin & SRV_ADMF_FMAINT))
195 srv_check_for_dup_dyncookie(s);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200196 out:
Willy Tarreau595e7672020-10-20 17:30:08 +0200197 HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &p->lock);
Olivier Houchard4e694042017-03-14 20:01:29 +0100198}
199
Willy Tarreau21faa912012-10-10 08:27:36 +0200200/*
Thayne McCombs92149f92020-11-20 01:28:26 -0700201 * Must be called with the server lock held, and will write-lock the proxy.
202 */
203static void srv_set_addr_desc(struct server *s)
204{
205 struct proxy *p = s->proxy;
206 char *key;
207
208 key = sa2str(&s->addr, s->svc_port, s->flags & SRV_F_MAPPORTS);
209
210 if (s->addr_node.key) {
Thayne McCombs24da7e12021-01-05 23:10:09 -0700211 if (key && strcmp(key, s->addr_node.key) == 0) {
Thayne McCombs92149f92020-11-20 01:28:26 -0700212 free(key);
213 return;
214 }
215
216 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
217 ebpt_delete(&s->addr_node);
218 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
219
220 free(s->addr_node.key);
221 }
222
223 s->addr_node.key = key;
224
Thayne McCombs24da7e12021-01-05 23:10:09 -0700225 if (s->addr_node.key) {
226 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
227 ebis_insert(&p->used_server_addr, &s->addr_node);
228 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
229 }
Thayne McCombs92149f92020-11-20 01:28:26 -0700230}
231
232/*
Willy Tarreau21faa912012-10-10 08:27:36 +0200233 * Registers the server keyword list <kwl> as a list of valid keywords for next
234 * parsing sessions.
235 */
236void srv_register_keywords(struct srv_kw_list *kwl)
237{
238 LIST_ADDQ(&srv_keywords.list, &kwl->list);
239}
240
241/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
242 * keyword is found with a NULL ->parse() function, then an attempt is made to
243 * find one with a valid ->parse() function. This way it is possible to declare
244 * platform-dependant, known keywords as NULL, then only declare them as valid
245 * if some options are met. Note that if the requested keyword contains an
246 * opening parenthesis, everything from this point is ignored.
247 */
248struct srv_kw *srv_find_kw(const char *kw)
249{
250 int index;
251 const char *kwend;
252 struct srv_kw_list *kwl;
253 struct srv_kw *ret = NULL;
254
255 kwend = strchr(kw, '(');
256 if (!kwend)
257 kwend = kw + strlen(kw);
258
259 list_for_each_entry(kwl, &srv_keywords.list, list) {
260 for (index = 0; kwl->kw[index].kw != NULL; index++) {
261 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
262 kwl->kw[index].kw[kwend-kw] == 0) {
263 if (kwl->kw[index].parse)
264 return &kwl->kw[index]; /* found it !*/
265 else
266 ret = &kwl->kw[index]; /* may be OK */
267 }
268 }
269 }
270 return ret;
271}
272
273/* Dumps all registered "server" keywords to the <out> string pointer. The
274 * unsupported keywords are only dumped if their supported form was not
275 * found.
276 */
277void srv_dump_kws(char **out)
278{
279 struct srv_kw_list *kwl;
280 int index;
281
Christopher Faulet784063e2020-05-18 12:14:18 +0200282 if (!out)
283 return;
284
Willy Tarreau21faa912012-10-10 08:27:36 +0200285 *out = NULL;
286 list_for_each_entry(kwl, &srv_keywords.list, list) {
287 for (index = 0; kwl->kw[index].kw != NULL; index++) {
288 if (kwl->kw[index].parse ||
289 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
290 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
291 kwl->scope,
292 kwl->kw[index].kw,
293 kwl->kw[index].skip ? " <arg>" : "",
294 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
295 kwl->kw[index].parse ? "" : " (not supported)");
296 }
297 }
298 }
299}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100300
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100301/* Parse the "backup" server keyword */
302static int srv_parse_backup(char **args, int *cur_arg,
303 struct proxy *curproxy, struct server *newsrv, char **err)
304{
305 newsrv->flags |= SRV_F_BACKUP;
306 return 0;
307}
308
Alexander Liu2a54bb72019-05-22 19:44:48 +0800309
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100310/* Parse the "cookie" server keyword */
311static int srv_parse_cookie(char **args, int *cur_arg,
312 struct proxy *curproxy, struct server *newsrv, char **err)
313{
314 char *arg;
315
316 arg = args[*cur_arg + 1];
317 if (!*arg) {
318 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
319 return ERR_ALERT | ERR_FATAL;
320 }
321
322 free(newsrv->cookie);
323 newsrv->cookie = strdup(arg);
324 newsrv->cklen = strlen(arg);
325 newsrv->flags |= SRV_F_COOKIESET;
326 return 0;
327}
328
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100329/* Parse the "disabled" server keyword */
330static int srv_parse_disabled(char **args, int *cur_arg,
331 struct proxy *curproxy, struct server *newsrv, char **err)
332{
Emeric Brun52a91d32017-08-31 14:41:55 +0200333 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
334 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100335 newsrv->check.state |= CHK_ST_PAUSED;
336 newsrv->check.health = 0;
337 return 0;
338}
339
340/* Parse the "enabled" server keyword */
341static int srv_parse_enabled(char **args, int *cur_arg,
342 struct proxy *curproxy, struct server *newsrv, char **err)
343{
Emeric Brun52a91d32017-08-31 14:41:55 +0200344 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
345 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100346 newsrv->check.state &= ~CHK_ST_PAUSED;
347 newsrv->check.health = newsrv->check.rise;
348 return 0;
349}
350
Willy Tarreau9c538e02019-01-23 10:21:49 +0100351static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
352{
353 char *arg;
354
355 arg = args[*cur_arg + 1];
356 if (!*arg) {
357 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
358 return ERR_ALERT | ERR_FATAL;
359 }
360 newsrv->max_reuse = atoi(arg);
361
362 return 0;
363}
364
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100365static 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 +0100366{
367 const char *res;
368 char *arg;
369 unsigned int time;
370
371 arg = args[*cur_arg + 1];
372 if (!*arg) {
373 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
374 return ERR_ALERT | ERR_FATAL;
375 }
376 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200377 if (res == PARSE_TIME_OVER) {
378 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
379 args[*cur_arg+1], args[*cur_arg]);
380 return ERR_ALERT | ERR_FATAL;
381 }
382 else if (res == PARSE_TIME_UNDER) {
383 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
384 args[*cur_arg+1], args[*cur_arg]);
385 return ERR_ALERT | ERR_FATAL;
386 }
387 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100388 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
389 *res, args[*cur_arg]);
390 return ERR_ALERT | ERR_FATAL;
391 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100392 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100393
394 return 0;
395}
396
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200397static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
398{
399 char *arg;
400
401 arg = args[*cur_arg + 1];
402 if (!*arg) {
403 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
404 return ERR_ALERT | ERR_FATAL;
405 }
406
407 newsrv->low_idle_conns = atoi(arg);
408 return 0;
409}
410
Olivier Houchard006e3102018-12-10 18:30:32 +0100411static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
412{
413 char *arg;
414
415 arg = args[*cur_arg + 1];
416 if (!*arg) {
417 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
418 return ERR_ALERT | ERR_FATAL;
419 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100420
Olivier Houchard006e3102018-12-10 18:30:32 +0100421 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100422 if ((int)newsrv->max_idle_conns < -1) {
423 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
424 return ERR_ALERT | ERR_FATAL;
425 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100426
427 return 0;
428}
429
Willy Tarreaudff55432012-10-10 17:51:05 +0200430/* parse the "id" server keyword */
431static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
432{
433 struct eb32_node *node;
434
435 if (!*args[*cur_arg + 1]) {
436 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
437 return ERR_ALERT | ERR_FATAL;
438 }
439
440 newsrv->puid = atol(args[*cur_arg + 1]);
441 newsrv->conf.id.key = newsrv->puid;
442
443 if (newsrv->puid <= 0) {
444 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
445 return ERR_ALERT | ERR_FATAL;
446 }
447
448 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
449 if (node) {
450 struct server *target = container_of(node, struct server, conf.id);
451 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
452 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
453 target->id);
454 return ERR_ALERT | ERR_FATAL;
455 }
456
457 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200458 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200459 return 0;
460}
461
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100462/* Parse the "namespace" server keyword */
463static int srv_parse_namespace(char **args, int *cur_arg,
464 struct proxy *curproxy, struct server *newsrv, char **err)
465{
Willy Tarreaue5733232019-05-22 19:24:06 +0200466#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100467 char *arg;
468
469 arg = args[*cur_arg + 1];
470 if (!*arg) {
471 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
472 return ERR_ALERT | ERR_FATAL;
473 }
474
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100475 if (strcmp(arg, "*") == 0) {
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100476 /* Use the namespace associated with the connection (if present). */
477 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
478 return 0;
479 }
480
481 /*
482 * As this parser may be called several times for the same 'default-server'
483 * object, or for a new 'server' instance deriving from a 'default-server'
484 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
485 */
486 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
487
488 newsrv->netns = netns_store_lookup(arg, strlen(arg));
489 if (!newsrv->netns)
490 newsrv->netns = netns_store_insert(arg);
491
492 if (!newsrv->netns) {
493 memprintf(err, "Cannot open namespace '%s'", arg);
494 return ERR_ALERT | ERR_FATAL;
495 }
496
497 return 0;
498#else
499 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
500 return ERR_ALERT | ERR_FATAL;
501#endif
502}
503
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100504/* Parse the "no-backup" server keyword */
505static int srv_parse_no_backup(char **args, int *cur_arg,
506 struct proxy *curproxy, struct server *newsrv, char **err)
507{
508 newsrv->flags &= ~SRV_F_BACKUP;
509 return 0;
510}
511
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100512
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100513/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200514static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100515{
516 srv->pp_opts &= ~flags;
517 return 0;
518}
519
520/* Parse the "no-send-proxy" server keyword */
521static int srv_parse_no_send_proxy(char **args, int *cur_arg,
522 struct proxy *curproxy, struct server *newsrv, char **err)
523{
524 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
525}
526
527/* Parse the "no-send-proxy-v2" server keyword */
528static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
529 struct proxy *curproxy, struct server *newsrv, char **err)
530{
531 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
532}
533
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200534/* Parse the "no-tfo" server keyword */
535static int srv_parse_no_tfo(char **args, int *cur_arg,
536 struct proxy *curproxy, struct server *newsrv, char **err)
537{
538 newsrv->flags &= ~SRV_F_FASTOPEN;
539 return 0;
540}
541
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100542/* Parse the "non-stick" server keyword */
543static int srv_parse_non_stick(char **args, int *cur_arg,
544 struct proxy *curproxy, struct server *newsrv, char **err)
545{
546 newsrv->flags |= SRV_F_NON_STICK;
547 return 0;
548}
549
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100550/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200551static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100552{
553 srv->pp_opts |= flags;
554 return 0;
555}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200556/* parse the "proto" server keyword */
557static int srv_parse_proto(char **args, int *cur_arg,
558 struct proxy *px, struct server *newsrv, char **err)
559{
560 struct ist proto;
561
562 if (!*args[*cur_arg + 1]) {
563 memprintf(err, "'%s' : missing value", args[*cur_arg]);
564 return ERR_ALERT | ERR_FATAL;
565 }
566 proto = ist2(args[*cur_arg + 1], strlen(args[*cur_arg + 1]));
567 newsrv->mux_proto = get_mux_proto(proto);
568 if (!newsrv->mux_proto) {
569 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
570 return ERR_ALERT | ERR_FATAL;
571 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200572 return 0;
573}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100574
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100575/* parse the "proxy-v2-options" */
576static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
577 struct proxy *px, struct server *newsrv, char **err)
578{
579 char *p, *n;
580 for (p = args[*cur_arg+1]; p; p = n) {
581 n = strchr(p, ',');
582 if (n)
583 *n++ = '\0';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100584 if (strcmp(p, "ssl") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100585 newsrv->pp_opts |= SRV_PP_V2_SSL;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100586 } else if (strcmp(p, "cert-cn") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100587 newsrv->pp_opts |= SRV_PP_V2_SSL;
588 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100589 } else if (strcmp(p, "cert-key") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100590 newsrv->pp_opts |= SRV_PP_V2_SSL;
591 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100592 } else if (strcmp(p, "cert-sig") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100593 newsrv->pp_opts |= SRV_PP_V2_SSL;
594 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100595 } else if (strcmp(p, "ssl-cipher") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100596 newsrv->pp_opts |= SRV_PP_V2_SSL;
597 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100598 } else if (strcmp(p, "authority") == 0) {
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100599 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100600 } else if (strcmp(p, "crc32c") == 0) {
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100601 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100602 } else if (strcmp(p, "unique-id") == 0) {
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100603 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100604 } else
605 goto fail;
606 }
607 return 0;
608 fail:
609 if (err)
610 memprintf(err, "'%s' : proxy v2 option not implemented", p);
611 return ERR_ALERT | ERR_FATAL;
612}
613
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100614/* Parse the "observe" server keyword */
615static int srv_parse_observe(char **args, int *cur_arg,
616 struct proxy *curproxy, struct server *newsrv, char **err)
617{
618 char *arg;
619
620 arg = args[*cur_arg + 1];
621 if (!*arg) {
622 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
623 return ERR_ALERT | ERR_FATAL;
624 }
625
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100626 if (strcmp(arg, "none") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100627 newsrv->observe = HANA_OBS_NONE;
628 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100629 else if (strcmp(arg, "layer4") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100630 newsrv->observe = HANA_OBS_LAYER4;
631 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100632 else if (strcmp(arg, "layer7") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100633 if (curproxy->mode != PR_MODE_HTTP) {
634 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
635 return ERR_ALERT;
636 }
637 newsrv->observe = HANA_OBS_LAYER7;
638 }
639 else {
640 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
641 "but got '%s'\n", args[*cur_arg], arg);
642 return ERR_ALERT | ERR_FATAL;
643 }
644
645 return 0;
646}
647
Frédéric Lécaille16186232017-03-14 16:42:49 +0100648/* Parse the "redir" server keyword */
649static int srv_parse_redir(char **args, int *cur_arg,
650 struct proxy *curproxy, struct server *newsrv, char **err)
651{
652 char *arg;
653
654 arg = args[*cur_arg + 1];
655 if (!*arg) {
656 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
657 return ERR_ALERT | ERR_FATAL;
658 }
659
660 free(newsrv->rdr_pfx);
661 newsrv->rdr_pfx = strdup(arg);
662 newsrv->rdr_len = strlen(arg);
663
664 return 0;
665}
666
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100667/* Parse the "send-proxy" server keyword */
668static int srv_parse_send_proxy(char **args, int *cur_arg,
669 struct proxy *curproxy, struct server *newsrv, char **err)
670{
671 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
672}
673
674/* Parse the "send-proxy-v2" server keyword */
675static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
676 struct proxy *curproxy, struct server *newsrv, char **err)
677{
678 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
679}
680
Frédéric Lécailledba97072017-03-17 15:33:50 +0100681
682/* Parse the "source" server keyword */
683static int srv_parse_source(char **args, int *cur_arg,
684 struct proxy *curproxy, struct server *newsrv, char **err)
685{
686 char *errmsg;
687 int port_low, port_high;
688 struct sockaddr_storage *sk;
Frédéric Lécailledba97072017-03-17 15:33:50 +0100689
690 errmsg = NULL;
691
692 if (!*args[*cur_arg + 1]) {
693 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
694 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
695 goto err;
696 }
697
698 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200699 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
700 &errmsg, NULL, NULL,
701 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 +0100702 if (!sk) {
703 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
704 goto err;
705 }
706
Frédéric Lécailledba97072017-03-17 15:33:50 +0100707 newsrv->conn_src.opts |= CO_SRC_BIND;
708 newsrv->conn_src.source_addr = *sk;
709
710 if (port_low != port_high) {
711 int i;
712
Frédéric Lécailledba97072017-03-17 15:33:50 +0100713 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
714 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
715 newsrv->conn_src.sport_range->ports[i] = port_low + i;
716 }
717
718 *cur_arg += 2;
719 while (*(args[*cur_arg])) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100720 if (strcmp(args[*cur_arg], "usesrc") == 0) { /* address to use outside */
Frédéric Lécailledba97072017-03-17 15:33:50 +0100721#if defined(CONFIG_HAP_TRANSPARENT)
722 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100723 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
724 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100725 goto err;
726 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100727 if (strcmp(args[*cur_arg + 1], "client") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +0100728 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
729 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
730 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100731 else if (strcmp(args[*cur_arg + 1], "clientip") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +0100732 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
733 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
734 }
735 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
736 char *name, *end;
737
738 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +0100739 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100740 name++;
741
742 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +0100743 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +0100744 end++;
745
746 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
747 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
748 free(newsrv->conn_src.bind_hdr_name);
749 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
750 newsrv->conn_src.bind_hdr_len = end - name;
751 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
752 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
753 newsrv->conn_src.bind_hdr_occ = -1;
754
755 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +0100756 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100757 end++;
758 if (*end == ',') {
759 end++;
760 name = end;
761 if (*end == '-')
762 end++;
Willy Tarreau90807112020-02-25 08:16:33 +0100763 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100764 end++;
765 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
766 }
767
768 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100769 ha_alert("usesrc hdr_ip(name,num) does not support negative"
770 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100771 goto err;
772 }
773 }
774 else {
775 struct sockaddr_storage *sk;
776 int port1, port2;
777
778 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200779 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, NULL, NULL,
780 &errmsg, NULL, NULL,
781 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100782 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100783 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100784 goto err;
785 }
786
Frédéric Lécailledba97072017-03-17 15:33:50 +0100787 newsrv->conn_src.tproxy_addr = *sk;
788 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
789 }
790 global.last_checks |= LSTCHK_NETADM;
791 *cur_arg += 2;
792 continue;
793#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100794 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 +0100795 goto err;
796#endif /* defined(CONFIG_HAP_TRANSPARENT) */
797 } /* "usesrc" */
798
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100799 if (strcmp(args[*cur_arg], "interface") == 0) { /* specifically bind to this interface */
Frédéric Lécailledba97072017-03-17 15:33:50 +0100800#ifdef SO_BINDTODEVICE
801 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100802 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100803 goto err;
804 }
805 free(newsrv->conn_src.iface_name);
806 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
807 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
808 global.last_checks |= LSTCHK_NETADM;
809#else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100810 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100811 goto err;
812#endif
813 *cur_arg += 2;
814 continue;
815 }
816 /* this keyword in not an option of "source" */
817 break;
818 } /* while */
819
820 return 0;
821
822 err:
823 free(errmsg);
824 return ERR_ALERT | ERR_FATAL;
825}
826
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100827/* Parse the "stick" server keyword */
828static int srv_parse_stick(char **args, int *cur_arg,
829 struct proxy *curproxy, struct server *newsrv, char **err)
830{
831 newsrv->flags &= ~SRV_F_NON_STICK;
832 return 0;
833}
834
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100835/* Parse the "track" server keyword */
836static int srv_parse_track(char **args, int *cur_arg,
837 struct proxy *curproxy, struct server *newsrv, char **err)
838{
839 char *arg;
840
841 arg = args[*cur_arg + 1];
842 if (!*arg) {
843 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
844 return ERR_ALERT | ERR_FATAL;
845 }
846
847 free(newsrv->trackit);
848 newsrv->trackit = strdup(arg);
849
850 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800851}
852
853/* Parse the "socks4" server keyword */
854static int srv_parse_socks4(char **args, int *cur_arg,
855 struct proxy *curproxy, struct server *newsrv, char **err)
856{
857 char *errmsg;
858 int port_low, port_high;
859 struct sockaddr_storage *sk;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800860
861 errmsg = NULL;
862
863 if (!*args[*cur_arg + 1]) {
864 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
865 goto err;
866 }
867
868 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200869 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
870 &errmsg, NULL, NULL,
871 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_CONNECT);
Alexander Liu2a54bb72019-05-22 19:44:48 +0800872 if (!sk) {
873 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
874 goto err;
875 }
876
Alexander Liu2a54bb72019-05-22 19:44:48 +0800877 newsrv->flags |= SRV_F_SOCKS4_PROXY;
878 newsrv->socks4_addr = *sk;
879
Alexander Liu2a54bb72019-05-22 19:44:48 +0800880 return 0;
881
882 err:
883 free(errmsg);
884 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100885}
886
Frédéric Lécailledba97072017-03-17 15:33:50 +0100887
Willy Tarreau034c88c2017-01-23 23:36:45 +0100888/* parse the "tfo" server keyword */
889static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
890{
891 newsrv->flags |= SRV_F_FASTOPEN;
892 return 0;
893}
894
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200895/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200896 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200897 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200898 *
899 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200900 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200901void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200902{
Willy Tarreau87b09662015-04-03 00:22:06 +0200903 struct stream *stream, *stream_bck;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200904
Willy Tarreau87b09662015-04-03 00:22:06 +0200905 list_for_each_entry_safe(stream, stream_bck, &srv->actconns, by_srv)
906 if (stream->srv_conn == srv)
907 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200908}
909
910/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200911 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200912 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200913 *
914 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200915 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200916void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200917{
918 struct server *srv;
919
920 for (srv = px->srv; srv != NULL; srv = srv->next)
921 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200922 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200923}
924
Willy Tarreaubda92272014-05-20 21:55:30 +0200925/* Appends some information to a message string related to a server going UP or
926 * DOWN. If both <forced> and <reason> are null and the server tracks another
927 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +0200928 * If <check> is non-null, an entire string describing the check result will be
929 * appended after a comma and a space (eg: to report some information from the
930 * check that changed the state). In the other case, the string will be built
931 * using the check results stored into the struct server if present.
932 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +0200933 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200934 *
935 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200936 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200937void srv_append_status(struct buffer *msg, struct server *s,
938 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200939{
Emeric Brun5a133512017-10-19 14:42:30 +0200940 short status = s->op_st_chg.status;
941 short code = s->op_st_chg.code;
942 long duration = s->op_st_chg.duration;
943 char *desc = s->op_st_chg.reason;
944
945 if (check) {
946 status = check->status;
947 code = check->code;
948 duration = check->duration;
949 desc = check->desc;
950 }
951
952 if (status != -1) {
953 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
954
955 if (status >= HCHK_STATUS_L57DATA)
956 chunk_appendf(msg, ", code: %d", code);
957
958 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200959 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +0200960
961 chunk_appendf(msg, ", info: \"");
962
963 chunk_initlen(&src, desc, 0, strlen(desc));
964 chunk_asciiencode(msg, &src, '"');
965
966 chunk_appendf(msg, "\"");
967 }
968
969 if (duration >= 0)
970 chunk_appendf(msg, ", check duration: %ldms", duration);
971 }
972 else if (desc && *desc) {
973 chunk_appendf(msg, ", %s", desc);
974 }
975 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +0200976 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +0200977 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200978
979 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200980 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200981 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
982 " %d sessions active, %d requeued, %d remaining in queue",
983 s->proxy->srv_act, s->proxy->srv_bck,
984 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
985 s->cur_sess, xferred, s->nbpend);
986 else
987 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
988 " %d sessions requeued, %d total in queue",
989 s->proxy->srv_act, s->proxy->srv_bck,
990 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
991 xferred, s->nbpend);
992 }
993}
994
Emeric Brun5a133512017-10-19 14:42:30 +0200995/* Marks server <s> down, regardless of its checks' statuses. The server is
996 * registered in a list to postpone the counting of the remaining servers on
997 * the proxy and transfers queued streams whenever possible to other servers at
998 * a sync point. Maintenance servers are ignored. It stores the <reason> if
999 * non-null as the reason for going down or the available data from the check
1000 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001001 *
1002 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001003 */
Emeric Brun5a133512017-10-19 14:42:30 +02001004void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001005{
1006 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001007
Emeric Brun64cc49c2017-10-03 14:46:45 +02001008 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001009 return;
1010
Emeric Brun52a91d32017-08-31 14:41:55 +02001011 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001012 *s->op_st_chg.reason = 0;
1013 s->op_st_chg.status = -1;
1014 if (reason) {
1015 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1016 }
1017 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001018 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001019 s->op_st_chg.code = check->code;
1020 s->op_st_chg.status = check->status;
1021 s->op_st_chg.duration = check->duration;
1022 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001023
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001024 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001025 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001026
Emeric Brun9f0b4582017-10-23 14:39:51 +02001027 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001028 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001029 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001030 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001031 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001032}
1033
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001034/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001035 * in maintenance. The server is registered in a list to postpone the counting
1036 * of the remaining servers on the proxy and tries to grab requests from the
1037 * proxy at a sync point. Maintenance servers are ignored. It stores the
1038 * <reason> if non-null as the reason for going down or the available data
1039 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001040 *
1041 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001042 */
Emeric Brun5a133512017-10-19 14:42:30 +02001043void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001044{
1045 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001046
Emeric Brun64cc49c2017-10-03 14:46:45 +02001047 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001048 return;
1049
Emeric Brun52a91d32017-08-31 14:41:55 +02001050 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001051 return;
1052
Emeric Brun52a91d32017-08-31 14:41:55 +02001053 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001054 *s->op_st_chg.reason = 0;
1055 s->op_st_chg.status = -1;
1056 if (reason) {
1057 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1058 }
1059 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001060 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001061 s->op_st_chg.code = check->code;
1062 s->op_st_chg.status = check->status;
1063 s->op_st_chg.duration = check->duration;
1064 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001065
Emeric Brun64cc49c2017-10-03 14:46:45 +02001066 if (s->slowstart <= 0)
1067 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001068
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001069 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001070 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001071
Emeric Brun9f0b4582017-10-23 14:39:51 +02001072 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001073 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001074 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001075 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001076 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001077}
1078
Willy Tarreau8eb77842014-05-21 13:54:57 +02001079/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001080 * isn't in maintenance. The server is registered in a list to postpone the
1081 * counting of the remaining servers on the proxy and tries to grab requests
1082 * from the proxy. Maintenance servers are ignored. It stores the
1083 * <reason> if non-null as the reason for going down or the available data
1084 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001085 * up. Note that it makes use of the trash to build the log strings, so <reason>
1086 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001087 *
1088 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001089 */
Emeric Brun5a133512017-10-19 14:42:30 +02001090void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001091{
1092 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001093
Emeric Brun64cc49c2017-10-03 14:46:45 +02001094 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001095 return;
1096
Emeric Brun52a91d32017-08-31 14:41:55 +02001097 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001098 return;
1099
Emeric Brun52a91d32017-08-31 14:41:55 +02001100 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001101 *s->op_st_chg.reason = 0;
1102 s->op_st_chg.status = -1;
1103 if (reason) {
1104 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1105 }
1106 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001107 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001108 s->op_st_chg.code = check->code;
1109 s->op_st_chg.status = check->status;
1110 s->op_st_chg.duration = check->duration;
1111 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001112
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001113 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001114 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001115
Emeric Brun9f0b4582017-10-23 14:39:51 +02001116 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001117 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001118 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001119 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001120 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001121}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001122
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001123/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1124 * enforce either maint mode or drain mode. It is not allowed to set more than
1125 * one flag at once. The equivalent "inherited" flag is propagated to all
1126 * tracking servers. Maintenance mode disables health checks (but not agent
1127 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001128 * is done. If <cause> is non-null, it will be displayed at the end of the log
1129 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001130 *
1131 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001132 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001133void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001134{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001135 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001136
1137 if (!mode)
1138 return;
1139
1140 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001141 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001142 return;
1143
Emeric Brun52a91d32017-08-31 14:41:55 +02001144 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001145 if (cause)
1146 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1147
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001148 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001149 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001150
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001151 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001152 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1153 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001154 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001155
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001156 /* compute the inherited flag to propagate */
1157 if (mode & SRV_ADMF_MAINT)
1158 mode = SRV_ADMF_IMAINT;
1159 else if (mode & SRV_ADMF_DRAIN)
1160 mode = SRV_ADMF_IDRAIN;
1161
Emeric Brun9f0b4582017-10-23 14:39:51 +02001162 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001163 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001164 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001165 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001166 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001167}
1168
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001169/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1170 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1171 * than one flag at once. The equivalent "inherited" flag is propagated to all
1172 * tracking servers. Leaving maintenance mode re-enables health checks. When
1173 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001174 *
1175 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001176 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001177void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001178{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001179 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001180
1181 if (!mode)
1182 return;
1183
1184 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001185 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001186 return;
1187
Emeric Brun52a91d32017-08-31 14:41:55 +02001188 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001189
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001190 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001191 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001192
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001193 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001194 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1195 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001196 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001197
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001198 if (mode & SRV_ADMF_MAINT)
1199 mode = SRV_ADMF_IMAINT;
1200 else if (mode & SRV_ADMF_DRAIN)
1201 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001202
Emeric Brun9f0b4582017-10-23 14:39:51 +02001203 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001204 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001205 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001206 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001207 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001208}
1209
Willy Tarreau757478e2016-11-03 19:22:19 +01001210/* principle: propagate maint and drain to tracking servers. This is useful
1211 * upon startup so that inherited states are correct.
1212 */
1213static void srv_propagate_admin_state(struct server *srv)
1214{
1215 struct server *srv2;
1216
1217 if (!srv->trackers)
1218 return;
1219
1220 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001221 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001222 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001223 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001224
Emeric Brun52a91d32017-08-31 14:41:55 +02001225 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001226 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001227 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001228 }
1229}
1230
1231/* Compute and propagate the admin states for all servers in proxy <px>.
1232 * Only servers *not* tracking another one are considered, because other
1233 * ones will be handled when the server they track is visited.
1234 */
1235void srv_compute_all_admin_states(struct proxy *px)
1236{
1237 struct server *srv;
1238
1239 for (srv = px->srv; srv; srv = srv->next) {
1240 if (srv->track)
1241 continue;
1242 srv_propagate_admin_state(srv);
1243 }
1244}
1245
Willy Tarreaudff55432012-10-10 17:51:05 +02001246/* Note: must not be declared <const> as its list will be overwritten.
1247 * Please take care of keeping this list alphabetically sorted, doing so helps
1248 * all code contributors.
1249 * Optional keywords are also declared with a NULL ->parse() function so that
1250 * the config parser can report an appropriate error when a known keyword was
1251 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001252 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001253 */
1254static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001255 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +01001256 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001257 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1258 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001259 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Willy Tarreau9c538e02019-01-23 10:21:49 +01001260 { "max-reuse", srv_parse_max_reuse, 1, 1 }, /* Set the max number of requests on a connection, -1 means unlimited */
Frédéric Lécaille22f41a22017-03-16 17:17:36 +01001261 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001262 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001263 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1264 { "no-send-proxy-v2", srv_parse_no_send_proxy_v2, 0, 1 }, /* Disable use of PROXY V2 protocol */
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +02001265 { "no-tfo", srv_parse_no_tfo, 0, 1 }, /* Disable use of TCP Fast Open */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001266 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001267 { "observe", srv_parse_observe, 1, 1 }, /* Enables health adjusting based on observing communication with the server */
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001268 { "pool-low-conn", srv_parse_pool_low_conn, 1, 1 }, /* Set the min number of orphan idle connecbefore being allowed to pick from other threads */
Amaury Denoyelle18c68df2021-01-26 14:35:24 +01001269 { "pool-max-conn", srv_parse_pool_max_conn, 1, 1 }, /* Set the max number of orphan idle connections, -1 means unlimited */
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001270 { "pool-purge-delay", srv_parse_pool_purge_delay, 1, 1 }, /* Set the time before we destroy orphan idle connections, defaults to 1s */
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001271 { "proto", srv_parse_proto, 1, 1 }, /* Set the proto to use for all outgoing connections */
Emmanuel Hocdetf643b802018-02-01 15:20:32 +01001272 { "proxy-v2-options", srv_parse_proxy_v2_options, 1, 1 }, /* options for send-proxy-v2 */
Frédéric Lécaille16186232017-03-14 16:42:49 +01001273 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001274 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1275 { "send-proxy-v2", srv_parse_send_proxy_v2, 0, 1 }, /* Enforce use of PROXY V2 protocol */
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001276 { "source", srv_parse_source, -1, 1 }, /* Set the source address to be used to connect to the server */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001277 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Olivier Houchard8d82db72019-07-04 13:34:10 +02001278 { "tfo", srv_parse_tfo, 0, 1 }, /* enable TCP Fast Open of server */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001279 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Alexander Liu2a54bb72019-05-22 19:44:48 +08001280 { "socks4", srv_parse_socks4, 1, 1 }, /* Set the socks4 proxy of the server*/
Willy Tarreaudff55432012-10-10 17:51:05 +02001281 { NULL, NULL, 0 },
1282}};
1283
Willy Tarreau0108d902018-11-25 19:14:37 +01001284INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001285
Willy Tarreau004e0452013-11-21 11:22:01 +01001286/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001287 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001288 * state is automatically disabled if the time is elapsed. If <must_update> is
1289 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001290 *
1291 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001292 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001293void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001294{
1295 struct proxy *px = sv->proxy;
1296 unsigned w;
1297
1298 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1299 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001300 if (sv->next_state == SRV_ST_STARTING)
1301 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001302 }
1303
1304 /* We must take care of not pushing the server to full throttle during slow starts.
1305 * It must also start immediately, at least at the minimal step when leaving maintenance.
1306 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001307 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001308 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1309 else
1310 w = px->lbprm.wdiv;
1311
Emeric Brun52a91d32017-08-31 14:41:55 +02001312 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001313
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001314 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001315 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001316 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001317}
1318
Willy Tarreaubaaee002006-06-26 02:48:02 +02001319/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001320 * Parses weight_str and configures sv accordingly.
1321 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001322 *
1323 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001324 */
1325const char *server_parse_weight_change_request(struct server *sv,
1326 const char *weight_str)
1327{
1328 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001329 long int w;
1330 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001331
1332 px = sv->proxy;
1333
1334 /* if the weight is terminated with '%', it is set relative to
1335 * the initial weight, otherwise it is absolute.
1336 */
1337 if (!*weight_str)
1338 return "Require <weight> or <weight%>.\n";
1339
Simon Hormanb796afa2013-02-12 10:45:53 +09001340 w = strtol(weight_str, &end, 10);
1341 if (end == weight_str)
1342 return "Empty weight string empty or preceded by garbage";
1343 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001344 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001345 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001346 /* Avoid integer overflow */
1347 if (w > 25600)
1348 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001349 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001350 if (w > 256)
1351 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001352 }
1353 else if (w < 0 || w > 256)
1354 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001355 else if (end[0] != '\0')
1356 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001357
1358 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1359 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1360
1361 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001362 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001363
1364 return NULL;
1365}
1366
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001367/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001368 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1369 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001370 * Returns:
1371 * - error string on error
1372 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001373 *
1374 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001375 */
1376const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001377 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001378{
1379 unsigned char ip[INET6_ADDRSTRLEN];
1380
1381 if (inet_pton(AF_INET6, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001382 update_server_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001383 return NULL;
1384 }
1385 if (inet_pton(AF_INET, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001386 update_server_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001387 return NULL;
1388 }
1389
1390 return "Could not understand IP address format.\n";
1391}
1392
Willy Tarreau46b7f532018-08-21 11:54:26 +02001393/*
1394 * Must be called with the server lock held.
1395 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001396const char *server_parse_maxconn_change_request(struct server *sv,
1397 const char *maxconn_str)
1398{
1399 long int v;
1400 char *end;
1401
1402 if (!*maxconn_str)
1403 return "Require <maxconn>.\n";
1404
1405 v = strtol(maxconn_str, &end, 10);
1406 if (end == maxconn_str)
1407 return "maxconn string empty or preceded by garbage";
1408 else if (end[0] != '\0')
1409 return "Trailing garbage in maxconn string";
1410
1411 if (sv->maxconn == sv->minconn) { // static maxconn
1412 sv->maxconn = sv->minconn = v;
1413 } else { // dynamic maxconn
1414 sv->maxconn = v;
1415 }
1416
1417 if (may_dequeue_tasks(sv, sv->proxy))
1418 process_srv_queue(sv);
1419
1420 return NULL;
1421}
1422
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001423#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001424static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1425 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001426{
1427 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001428 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001429 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001430 NULL,
1431 };
1432
1433 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001434 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001435
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001436 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001437}
1438
1439static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1440{
1441 struct sample_expr *expr;
1442
1443 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 +01001444 if (!expr) {
1445 memprintf(err, "error detected while parsing sni expression : %s", *err);
1446 return ERR_ALERT | ERR_FATAL;
1447 }
1448
1449 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1450 memprintf(err, "error detected while parsing sni expression : "
1451 " fetch method '%s' extracts information from '%s', "
1452 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001453 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001454 return ERR_ALERT | ERR_FATAL;
1455 }
1456
1457 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1458 release_sample_expr(newsrv->ssl_ctx.sni);
1459 newsrv->ssl_ctx.sni = expr;
1460
1461 return 0;
1462}
1463#endif
1464
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001465static 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 +01001466{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001467 char *msg = "error encountered while processing ";
1468 char *quote = "'";
1469 char *token = args[cur_arg];
1470
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001471 if (err && *err) {
1472 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001473 msg = *err;
1474 quote = "";
1475 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001476 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001477
1478 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
1479 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1480 file, linenum, args[0], args[1],
1481 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001482 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001483 ha_alert("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1484 file, linenum, args[0], args[1],
1485 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001486}
1487
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001488static void srv_conn_src_sport_range_cpy(struct server *srv,
1489 struct server *src)
1490{
1491 int range_sz;
1492
1493 range_sz = src->conn_src.sport_range->size;
1494 if (range_sz > 0) {
1495 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1496 if (srv->conn_src.sport_range != NULL) {
1497 int i;
1498
1499 for (i = 0; i < range_sz; i++) {
1500 srv->conn_src.sport_range->ports[i] =
1501 src->conn_src.sport_range->ports[i];
1502 }
1503 }
1504 }
1505}
1506
1507/*
1508 * Copy <src> server connection source settings to <srv> server everything needed.
1509 */
1510static void srv_conn_src_cpy(struct server *srv, struct server *src)
1511{
1512 srv->conn_src.opts = src->conn_src.opts;
1513 srv->conn_src.source_addr = src->conn_src.source_addr;
1514
1515 /* Source port range copy. */
1516 if (src->conn_src.sport_range != NULL)
1517 srv_conn_src_sport_range_cpy(srv, src);
1518
1519#ifdef CONFIG_HAP_TRANSPARENT
1520 if (src->conn_src.bind_hdr_name != NULL) {
1521 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1522 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1523 }
1524 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1525 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1526#endif
1527 if (src->conn_src.iface_name != NULL)
1528 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1529}
1530
1531/*
1532 * Copy <src> server SSL settings to <srv> server allocating
1533 * everything needed.
1534 */
1535#if defined(USE_OPENSSL)
1536static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1537{
1538 if (src->ssl_ctx.ca_file != NULL)
1539 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1540 if (src->ssl_ctx.crl_file != NULL)
1541 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001542
1543 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1544
1545 if (src->ssl_ctx.verify_host != NULL)
1546 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1547 if (src->ssl_ctx.ciphers != NULL)
1548 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02001549 if (src->ssl_ctx.options)
1550 srv->ssl_ctx.options = src->ssl_ctx.options;
1551 if (src->ssl_ctx.methods.flags)
1552 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
1553 if (src->ssl_ctx.methods.min)
1554 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
1555 if (src->ssl_ctx.methods.max)
1556 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
1557
Ilya Shipitsin2aa4b3a2021-01-07 11:55:45 +05001558#ifdef HAVE_SSL_CTX_SET_CIPHERSUITES
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001559 if (src->ssl_ctx.ciphersuites != NULL)
1560 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
1561#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001562 if (src->sni_expr != NULL)
1563 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001564
1565#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
1566 if (src->ssl_ctx.alpn_str) {
1567 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1568 if (srv->ssl_ctx.alpn_str) {
1569 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1570 src->ssl_ctx.alpn_len);
1571 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1572 }
1573 }
1574#endif
1575#ifdef OPENSSL_NPN_NEGOTIATED
1576 if (src->ssl_ctx.npn_str) {
1577 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1578 if (srv->ssl_ctx.npn_str) {
1579 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1580 src->ssl_ctx.npn_len);
1581 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1582 }
1583 }
1584#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001585}
1586#endif
1587
1588/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001589 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001590 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001591 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001592 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001593static int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001594{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001595 char *hostname_dn;
1596 int hostname_len, hostname_dn_len;
1597
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001598 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001599 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001600
Christopher Faulet67957bd2017-09-27 11:00:59 +02001601 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001602 hostname_dn = trash.area;
Emeric Brund30e9a12020-12-23 18:49:16 +01001603 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len + 1,
1604 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02001605 if (hostname_dn_len == -1)
1606 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001607
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001608
Christopher Faulet67957bd2017-09-27 11:00:59 +02001609 free(srv->hostname);
1610 free(srv->hostname_dn);
1611 srv->hostname = strdup(hostname);
1612 srv->hostname_dn = strdup(hostname_dn);
1613 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001614 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001615 goto err;
1616
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001617 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001618
1619 err:
Christopher Faulet67957bd2017-09-27 11:00:59 +02001620 free(srv->hostname); srv->hostname = NULL;
1621 free(srv->hostname_dn); srv->hostname_dn = NULL;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001622 return -1;
1623}
1624
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001625/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001626 * Copy <src> server settings to <srv> server allocating
1627 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001628 * This function is not supposed to be called at any time, but only
1629 * during server settings parsing or during server allocations from
1630 * a server template, and just after having calloc()'ed a new server.
1631 * So, <src> may only be a default server (when parsing server settings)
1632 * or a server template (during server allocations from a server template).
1633 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1634 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001635 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001636static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001637{
1638 /* Connection source settings copy */
1639 srv_conn_src_cpy(srv, src);
1640
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001641 if (srv_tmpl) {
1642 srv->addr = src->addr;
1643 srv->svc_port = src->svc_port;
1644 }
1645
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001646 srv->pp_opts = src->pp_opts;
1647 if (src->rdr_pfx != NULL) {
1648 srv->rdr_pfx = strdup(src->rdr_pfx);
1649 srv->rdr_len = src->rdr_len;
1650 }
1651 if (src->cookie != NULL) {
1652 srv->cookie = strdup(src->cookie);
1653 srv->cklen = src->cklen;
1654 }
1655 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01001656 srv->check.addr = src->check.addr;
1657 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001658 srv->check.use_ssl = src->check.use_ssl;
1659 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01001660 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01001661 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05001662 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001663 /* Note: 'flags' field has potentially been already initialized. */
1664 srv->flags |= src->flags;
1665 srv->do_check = src->do_check;
1666 srv->do_agent = src->do_agent;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001667 srv->check.inter = src->check.inter;
1668 srv->check.fastinter = src->check.fastinter;
1669 srv->check.downinter = src->check.downinter;
1670 srv->agent.use_ssl = src->agent.use_ssl;
1671 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001672
1673 if (src->agent.tcpcheck_rules) {
1674 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
1675 if (srv->agent.tcpcheck_rules) {
1676 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
1677 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
1678 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
1679 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
1680 &src->agent.tcpcheck_rules->preset_vars);
1681 }
1682 }
1683
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001684 srv->agent.inter = src->agent.inter;
1685 srv->agent.fastinter = src->agent.fastinter;
1686 srv->agent.downinter = src->agent.downinter;
1687 srv->maxqueue = src->maxqueue;
1688 srv->minconn = src->minconn;
1689 srv->maxconn = src->maxconn;
1690 srv->slowstart = src->slowstart;
1691 srv->observe = src->observe;
1692 srv->onerror = src->onerror;
1693 srv->onmarkeddown = src->onmarkeddown;
1694 srv->onmarkedup = src->onmarkedup;
1695 if (src->trackit != NULL)
1696 srv->trackit = strdup(src->trackit);
1697 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1698 srv->uweight = srv->iweight = src->iweight;
1699
1700 srv->check.send_proxy = src->check.send_proxy;
1701 /* health: up, but will fall down at first failure */
1702 srv->check.rise = srv->check.health = src->check.rise;
1703 srv->check.fall = src->check.fall;
1704
1705 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001706 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1707 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1708 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001709 srv->check.state |= CHK_ST_PAUSED;
1710 srv->check.health = 0;
1711 }
1712
1713 /* health: up but will fall down at first failure */
1714 srv->agent.rise = srv->agent.health = src->agent.rise;
1715 srv->agent.fall = src->agent.fall;
1716
1717 if (src->resolvers_id != NULL)
1718 srv->resolvers_id = strdup(src->resolvers_id);
Emeric Brun21fbeed2020-12-23 18:01:04 +01001719 srv->resolv_opts.family_prio = src->resolv_opts.family_prio;
1720 srv->resolv_opts.accept_duplicate_ip = src->resolv_opts.accept_duplicate_ip;
1721 srv->resolv_opts.ignore_weight = src->resolv_opts.ignore_weight;
1722 if (srv->resolv_opts.family_prio == AF_UNSPEC)
1723 srv->resolv_opts.family_prio = AF_INET6;
1724 memcpy(srv->resolv_opts.pref_net,
1725 src->resolv_opts.pref_net,
1726 sizeof srv->resolv_opts.pref_net);
1727 srv->resolv_opts.pref_net_nb = src->resolv_opts.pref_net_nb;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001728
1729 srv->init_addr_methods = src->init_addr_methods;
1730 srv->init_addr = src->init_addr;
1731#if defined(USE_OPENSSL)
1732 srv_ssl_settings_cpy(srv, src);
1733#endif
1734#ifdef TCP_USER_TIMEOUT
1735 srv->tcp_ut = src->tcp_ut;
1736#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001737 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001738 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001739 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01001740 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01001741 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001742
Olivier Houchard8da5f982017-08-04 18:35:36 +02001743 if (srv_tmpl)
1744 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001745
1746 srv->check.via_socks4 = src->check.via_socks4;
1747 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001748}
1749
William Lallemand313bfd12018-10-26 14:47:32 +02001750struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001751{
1752 struct server *srv;
1753
1754 srv = calloc(1, sizeof *srv);
1755 if (!srv)
1756 return NULL;
1757
1758 srv->obj_type = OBJ_TYPE_SERVER;
1759 srv->proxy = proxy;
1760 LIST_INIT(&srv->actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04001761 srv->pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02001762
Emeric Brun52a91d32017-08-31 14:41:55 +02001763 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001764 srv->last_change = now.tv_sec;
1765
Christopher Faulet38290462020-04-21 11:46:40 +02001766 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001767 srv->check.status = HCHK_STATUS_INI;
1768 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01001769 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02001770 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001771
Christopher Faulet38290462020-04-21 11:46:40 +02001772 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001773 srv->agent.status = HCHK_STATUS_INI;
1774 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01001775 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001776 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
Frédéric Lécaillef46c10c2020-11-23 14:29:28 +01001777#if defined(USE_QUIC)
1778 srv->cids = EB_ROOT_UNIQUE;
1779#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001780
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01001781 srv->extra_counters = NULL;
William Lallemand3ce6eed2021-02-08 10:43:44 +01001782#ifdef USE_OPENSSL
1783 HA_RWLOCK_INIT(&srv->ssl_ctx.lock);
1784#endif
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01001785
Willy Tarreau975b1552019-06-06 16:25:55 +02001786 /* please don't put default server settings here, they are set in
Willy Tarreau144289b2021-02-12 08:19:01 +01001787 * proxy_preset_defaults().
Willy Tarreau975b1552019-06-06 16:25:55 +02001788 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001789 return srv;
1790}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001791
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001792#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1793static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
1794 struct server *srv, struct proxy *proxy)
1795{
1796 int ret;
1797 char *err = NULL;
1798
1799 if (!srv->sni_expr)
1800 return 0;
1801
1802 ret = server_parse_sni_expr(srv, proxy, &err);
1803 if (!ret)
1804 return 0;
1805
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001806 display_parser_err(file, linenum, args, cur_arg, ret, &err);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001807 free(err);
1808
1809 return ret;
1810}
1811#endif
1812
1813/*
1814 * Server initializations finalization.
1815 * Initialize health check, agent check and SNI expression if enabled.
1816 * Must not be called for a default server instance.
1817 */
1818static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
1819 struct server *srv, struct proxy *px)
1820{
Christopher Fauletb3b53522020-04-27 11:17:10 +02001821#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001822 int ret;
Christopher Fauletb3b53522020-04-27 11:17:10 +02001823#endif
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001824
Christopher Faulet8892e5d2020-03-26 19:48:20 +01001825 if (srv->do_check && srv->trackit) {
1826 ha_alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1827 file, linenum);
1828 return ERR_ALERT | ERR_FATAL;
1829 }
1830
1831 if (srv->do_agent && !srv->agent.port) {
1832 ha_alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
1833 file, linenum, srv->id);
1834 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001835 }
1836
1837#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1838 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
1839 return ret;
1840#endif
1841
1842 if (srv->flags & SRV_F_BACKUP)
1843 px->srv_bck++;
1844 else
1845 px->srv_act++;
1846 srv_lb_commit_status(srv);
1847
1848 return 0;
1849}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001850
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001851/*
1852 * Parse as much as possible such a range string argument: low[-high]
1853 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
1854 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
1855 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
1856 * Returns 0 if succeeded, -1 if not.
1857 */
1858static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
1859{
1860 char *nb_high_arg;
1861
1862 *nb_high = 0;
1863 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001864 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001865
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001866 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001867 *nb_high_arg++ = '\0';
1868 *nb_high = atoi(nb_high_arg);
1869 }
1870 else {
1871 *nb_high += *nb_low;
1872 *nb_low = 1;
1873 }
1874
1875 if (*nb_low < 0 || *nb_high < *nb_low)
1876 return -1;
1877
1878 return 0;
1879}
1880
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001881static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
1882{
1883 chunk_printf(&trash, "%s%d", prefix, nb);
1884 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001885 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001886}
1887
1888/*
1889 * Initialize as much as possible servers from <srv> server template.
1890 * Note that a server template is a special server with
1891 * a few different parameters than a server which has
1892 * been parsed mostly the same way as a server.
Joseph Herlant44466822018-11-15 08:57:51 -08001893 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001894 * 'srv' template included.
1895 */
1896static int server_template_init(struct server *srv, struct proxy *px)
1897{
1898 int i;
1899 struct server *newsrv;
1900
1901 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 +02001902 newsrv = new_server(px);
1903 if (!newsrv)
1904 goto err;
1905
Christopher Faulet75bef002020-11-02 22:04:55 +01001906 newsrv->conf.file = strdup(srv->conf.file);
1907 newsrv->conf.line = srv->conf.line;
1908
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001909 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001910 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001911#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1912 if (newsrv->sni_expr) {
1913 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
1914 if (!newsrv->ssl_ctx.sni)
1915 goto err;
1916 }
1917#endif
1918 /* Set this new server ID. */
1919 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
1920
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001921 /* Linked backwards first. This will be restablished after parsing. */
1922 newsrv->next = px->srv;
1923 px->srv = newsrv;
1924 }
1925 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1926
1927 return i - srv->tmpl_info.nb_low;
1928
1929 err:
1930 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1931 if (newsrv) {
1932#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1933 release_sample_expr(newsrv->ssl_ctx.sni);
1934#endif
1935 free_check(&newsrv->agent);
1936 free_check(&newsrv->check);
1937 }
1938 free(newsrv);
1939 return i - srv->tmpl_info.nb_low;
1940}
1941
Emeric Brund3db3842020-07-21 16:54:36 +02001942int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy,
Willy Tarreaubb8669a2021-02-12 12:15:05 +01001943 const struct proxy *defproxy, int parse_addr, int in_peers_section, int initial_resolve)
Willy Tarreau272adea2014-03-31 10:39:59 +02001944{
1945 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001946 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001947 char *errmsg = NULL;
1948 int err_code = 0;
1949 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02001950 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001951
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001952 if (strcmp(args[0], "server") == 0 ||
1953 strcmp(args[0], "peer") == 0 ||
1954 strcmp(args[0], "default-server") == 0 ||
1955 strcmp(args[0], "server-template") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02001956 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001957 int defsrv = (*args[0] == 'd');
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001958 int srv = !defsrv && (*args[0] == 'p' || strcmp(args[0], "server") == 0);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001959 int srv_tmpl = !defsrv && !srv;
1960 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02001961
1962 if (!defsrv && curproxy == defproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001963 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001964 err_code |= ERR_ALERT | ERR_FATAL;
1965 goto out;
1966 }
Christopher Faulete3bdc812021-01-13 13:14:13 +01001967 else if (failifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL)) {
1968 err_code |= ERR_ALERT | ERR_FATAL;
1969 goto out;
1970 }
Willy Tarreau272adea2014-03-31 10:39:59 +02001971
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001972 /* There is no mandatory first arguments for default server. */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01001973 if (srv && parse_addr) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001974 if (!*args[2]) {
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +02001975 if (in_peers_section) {
1976 return 0;
1977 }
1978 else {
1979 /* 'server' line number of argument check. */
1980 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1981 file, linenum, args[0]);
1982 err_code |= ERR_ALERT | ERR_FATAL;
1983 goto out;
1984 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001985 }
1986
1987 err = invalid_char(args[1]);
1988 }
1989 else if (srv_tmpl) {
1990 if (!*args[3]) {
1991 /* 'server-template' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001992 ha_alert("parsing [%s:%d] : '%s' expects <prefix> <nb | range> <addr>[:<port>] as arguments.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001993 file, linenum, args[0]);
1994 err_code |= ERR_ALERT | ERR_FATAL;
1995 goto out;
1996 }
1997
1998 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001999 }
2000
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002001 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002002 ha_alert("parsing [%s:%d] : character '%c' is not permitted in %s %s '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002003 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002004 err_code |= ERR_ALERT | ERR_FATAL;
2005 goto out;
2006 }
2007
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002008 cur_arg = 2;
2009 if (srv_tmpl) {
2010 /* Parse server-template <nb | range> arg. */
2011 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002012 ha_alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002013 file, linenum, args[0], args[cur_arg]);
2014 err_code |= ERR_ALERT | ERR_FATAL;
2015 goto out;
2016 }
2017 cur_arg++;
2018 }
2019
Willy Tarreau272adea2014-03-31 10:39:59 +02002020 if (!defsrv) {
2021 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002022 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002023
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002024 newsrv = new_server(curproxy);
2025 if (!newsrv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002026 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Willy Tarreau272adea2014-03-31 10:39:59 +02002027 err_code |= ERR_ALERT | ERR_ABORT;
2028 goto out;
2029 }
2030
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002031 if (srv_tmpl) {
2032 newsrv->tmpl_info.nb_low = tmpl_range_low;
2033 newsrv->tmpl_info.nb_high = tmpl_range_high;
2034 }
2035
Willy Tarreau272adea2014-03-31 10:39:59 +02002036 /* the servers are linked backwards first */
2037 newsrv->next = curproxy->srv;
2038 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02002039 newsrv->conf.file = strdup(file);
2040 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002041 /* Note: for a server template, its id is its prefix.
2042 * This is a temporary id which will be used for server allocations to come
2043 * after parsing.
2044 */
2045 if (srv)
2046 newsrv->id = strdup(args[1]);
2047 else
2048 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002049
2050 /* several ways to check the port component :
2051 * - IP => port=+0, relative (IPv4 only)
2052 * - IP: => port=+0, relative
2053 * - IP:N => port=N, absolute
2054 * - IP:+N => port=+N, relative
2055 * - IP:-N => port=-N, relative
2056 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002057 if (!parse_addr)
2058 goto skip_addr;
2059
Willy Tarreau65ec4e32020-09-16 19:17:08 +02002060 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, NULL, NULL,
2061 &errmsg, NULL, &fqdn,
2062 (initial_resolve ? PA_O_RESOLVE : 0) | PA_O_PORT_OK | PA_O_PORT_OFS | PA_O_STREAM | PA_O_XPRT | PA_O_CONNECT);
Willy Tarreau272adea2014-03-31 10:39:59 +02002063 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002064 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau272adea2014-03-31 10:39:59 +02002065 err_code |= ERR_ALERT | ERR_FATAL;
2066 goto out;
2067 }
2068
Willy Tarreau272adea2014-03-31 10:39:59 +02002069 if (!port1 || !port2) {
2070 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002071 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002072 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002073
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002074 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002075 if (fqdn) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002076 if (fqdn[0] == '_') { /* SRV record */
Olivier Houchard8da5f982017-08-04 18:35:36 +02002077 /* Check if a SRV request already exists, and if not, create it */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002078 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
Emeric Brun08622d32020-12-23 17:41:43 +01002079 newsrv->srvrq = new_resolv_srvrq(newsrv, fqdn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02002080 if (newsrv->srvrq == NULL) {
Olivier Houchard8da5f982017-08-04 18:35:36 +02002081 err_code |= ERR_ALERT | ERR_FATAL;
2082 goto out;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002083 }
2084 }
2085 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002086 ha_alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
Christopher Faulet67957bd2017-09-27 11:00:59 +02002087 file, linenum, newsrv->id);
2088 err_code |= ERR_ALERT | ERR_FATAL;
2089 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002090 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002091 }
2092
Willy Tarreau272adea2014-03-31 10:39:59 +02002093 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002094 newsrv->svc_port = port;
Thayne McCombs92149f92020-11-20 01:28:26 -07002095 // we don't need to lock the server here, because
2096 // we are in the process of initializing
2097 srv_set_addr_desc(newsrv);
Willy Tarreau272adea2014-03-31 10:39:59 +02002098
Olivier Houchard8da5f982017-08-04 18:35:36 +02002099 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002100 ha_alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002101 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002102 err_code |= ERR_ALERT | ERR_FATAL;
2103 goto out;
2104 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002105
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002106 cur_arg++;
2107 skip_addr:
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002108 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002109 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002110 HA_SPIN_INIT(&newsrv->lock);
Willy Tarreau272adea2014-03-31 10:39:59 +02002111 } else {
2112 newsrv = &curproxy->defsrv;
2113 cur_arg = 1;
Emeric Brun21fbeed2020-12-23 18:01:04 +01002114 newsrv->resolv_opts.family_prio = AF_INET6;
2115 newsrv->resolv_opts.accept_duplicate_ip = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002116 }
2117
2118 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002119 if (strcmp(args[cur_arg], "init-addr") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002120 char *p, *end;
2121 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002122 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002123
2124 newsrv->init_addr_methods = 0;
2125 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2126
2127 for (p = args[cur_arg + 1]; *p; p = end) {
2128 /* cut on next comma */
2129 for (end = p; *end && *end != ','; end++);
2130 if (*end)
2131 *(end++) = 0;
2132
Willy Tarreau4310d362016-11-02 15:05:56 +01002133 memset(&sa, 0, sizeof(sa));
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002134 if (strcmp(p, "libc") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002135 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2136 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002137 else if (strcmp(p, "last") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002138 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2139 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002140 else if (strcmp(p, "none") == 0) {
Willy Tarreau37ebe122016-11-04 15:17:58 +01002141 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2142 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002143 else if (str2ip2(p, &sa, 0)) {
2144 if (is_addr(&newsrv->init_addr)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002145 ha_alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
Willy Tarreau4310d362016-11-02 15:05:56 +01002146 file, linenum, args[cur_arg], p);
2147 err_code |= ERR_ALERT | ERR_FATAL;
2148 goto out;
2149 }
2150 newsrv->init_addr = sa;
2151 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2152 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002153 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002154 ha_alert("parsing [%s:%d]: '%s' : unknown init-addr method '%s', supported methods are 'libc', 'last', 'none'.\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002155 file, linenum, args[cur_arg], p);
2156 err_code |= ERR_ALERT | ERR_FATAL;
2157 goto out;
2158 }
2159 if (!done) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002160 ha_alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002161 file, linenum, args[cur_arg], p);
2162 err_code |= ERR_ALERT | ERR_FATAL;
2163 goto out;
2164 }
2165 }
2166 cur_arg += 2;
2167 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002168 else if (strcmp(args[cur_arg], "resolvers") == 0) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002169 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002170 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2171 cur_arg += 2;
2172 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002173 else if (strcmp(args[cur_arg], "resolve-opts") == 0) {
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002174 char *p, *end;
2175
2176 for (p = args[cur_arg + 1]; *p; p = end) {
2177 /* cut on next comma */
2178 for (end = p; *end && *end != ','; end++);
2179 if (*end)
2180 *(end++) = 0;
2181
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002182 if (strcmp(p, "allow-dup-ip") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002183 newsrv->resolv_opts.accept_duplicate_ip = 1;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002184 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002185 else if (strcmp(p, "ignore-weight") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002186 newsrv->resolv_opts.ignore_weight = 1;
Daniel Corbettf8716912019-11-17 09:48:56 -05002187 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002188 else if (strcmp(p, "prevent-dup-ip") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002189 newsrv->resolv_opts.accept_duplicate_ip = 0;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002190 }
2191 else {
Daniel Corbettf8716912019-11-17 09:48:56 -05002192 ha_alert("parsing [%s:%d]: '%s' : unknown resolve-opts option '%s', supported methods are 'allow-dup-ip', 'ignore-weight', and 'prevent-dup-ip'.\n",
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002193 file, linenum, args[cur_arg], p);
2194 err_code |= ERR_ALERT | ERR_FATAL;
2195 goto out;
2196 }
2197 }
2198
2199 cur_arg += 2;
2200 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002201 else if (strcmp(args[cur_arg], "resolve-prefer") == 0) {
2202 if (strcmp(args[cur_arg + 1], "ipv4") == 0)
Emeric Brun21fbeed2020-12-23 18:01:04 +01002203 newsrv->resolv_opts.family_prio = AF_INET;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002204 else if (strcmp(args[cur_arg + 1], "ipv6") == 0)
Emeric Brun21fbeed2020-12-23 18:01:04 +01002205 newsrv->resolv_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002206 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002207 ha_alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002208 file, linenum, args[cur_arg]);
2209 err_code |= ERR_ALERT | ERR_FATAL;
2210 goto out;
2211 }
2212 cur_arg += 2;
2213 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002214 else if (strcmp(args[cur_arg], "resolve-net") == 0) {
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002215 char *p, *e;
2216 unsigned char mask;
Emeric Brun21fbeed2020-12-23 18:01:04 +01002217 struct resolv_options *opt;
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002218
2219 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002220 ha_alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002221 file, linenum, args[cur_arg]);
2222 err_code |= ERR_ALERT | ERR_FATAL;
2223 goto out;
2224 }
2225
Emeric Brun21fbeed2020-12-23 18:01:04 +01002226 opt = &newsrv->resolv_opts;
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002227
2228 /* Split arguments by comma, and convert it from ipv4 or ipv6
2229 * string network in in_addr or in6_addr.
2230 */
2231 p = args[cur_arg + 1];
2232 e = p;
2233 while (*p != '\0') {
Joseph Herlant44466822018-11-15 08:57:51 -08002234 /* If no room available, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002235 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002236 ha_alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002237 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2238 err_code |= ERR_ALERT | ERR_FATAL;
2239 goto out;
2240 }
2241 /* look for end or comma. */
2242 while (*e != ',' && *e != '\0')
2243 e++;
2244 if (*e == ',') {
2245 *e = '\0';
2246 e++;
2247 }
2248 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2249 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2250 /* Try to convert input string from ipv4 or ipv6 network. */
2251 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2252 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2253 &mask)) {
2254 /* Try to convert input string from ipv6 network. */
2255 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2256 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2257 } else {
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002258 /* All network conversions fail, return error. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002259 ha_alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002260 file, linenum, args[cur_arg], p);
2261 err_code |= ERR_ALERT | ERR_FATAL;
2262 goto out;
2263 }
2264 opt->pref_net_nb++;
2265 p = e;
2266 }
2267
2268 cur_arg += 2;
2269 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002270 else if (strcmp(args[cur_arg], "weight") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002271 int w;
2272 w = atol(args[cur_arg + 1]);
2273 if (w < 0 || w > SRV_UWGHT_MAX) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002274 ha_alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002275 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2276 err_code |= ERR_ALERT | ERR_FATAL;
2277 goto out;
2278 }
2279 newsrv->uweight = newsrv->iweight = w;
2280 cur_arg += 2;
2281 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002282 else if (strcmp(args[cur_arg], "log-proto") == 0) {
2283 if (strcmp(args[cur_arg + 1], "legacy") == 0)
Emeric Brun97556472020-05-30 01:42:45 +02002284 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002285 else if (strcmp(args[cur_arg + 1], "octet-count") == 0)
Emeric Brun97556472020-05-30 01:42:45 +02002286 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
2287 else {
2288 ha_alert("parsing [%s:%d]: '%s' expects one of 'legacy' or "
2289 "'octet-count' but got '%s'\n",
2290 file, linenum, args[cur_arg], args[cur_arg + 1]);
2291 err_code |= ERR_ALERT | ERR_FATAL;
2292 goto out;
2293 }
2294 cur_arg += 2;
2295 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002296 else if (strcmp(args[cur_arg], "minconn") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002297 newsrv->minconn = atol(args[cur_arg + 1]);
2298 cur_arg += 2;
2299 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002300 else if (strcmp(args[cur_arg], "maxconn") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002301 newsrv->maxconn = atol(args[cur_arg + 1]);
2302 cur_arg += 2;
2303 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002304 else if (strcmp(args[cur_arg], "maxqueue") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002305 newsrv->maxqueue = atol(args[cur_arg + 1]);
2306 cur_arg += 2;
2307 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002308 else if (strcmp(args[cur_arg], "slowstart") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002309 /* slowstart is stored in seconds */
2310 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02002311
2312 if (err == PARSE_TIME_OVER) {
2313 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).\n",
2314 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2315 err_code |= ERR_ALERT | ERR_FATAL;
2316 goto out;
2317 }
2318 else if (err == PARSE_TIME_UNDER) {
2319 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.\n",
2320 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2321 err_code |= ERR_ALERT | ERR_FATAL;
2322 goto out;
2323 }
2324 else if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002325 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002326 file, linenum, *err, newsrv->id);
2327 err_code |= ERR_ALERT | ERR_FATAL;
2328 goto out;
2329 }
2330 newsrv->slowstart = (val + 999) / 1000;
2331 cur_arg += 2;
2332 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002333 else if (strcmp(args[cur_arg], "on-error") == 0) {
2334 if (strcmp(args[cur_arg + 1], "fastinter") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002335 newsrv->onerror = HANA_ONERR_FASTINTER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002336 else if (strcmp(args[cur_arg + 1], "fail-check") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002337 newsrv->onerror = HANA_ONERR_FAILCHK;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002338 else if (strcmp(args[cur_arg + 1], "sudden-death") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002339 newsrv->onerror = HANA_ONERR_SUDDTH;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002340 else if (strcmp(args[cur_arg + 1], "mark-down") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002341 newsrv->onerror = HANA_ONERR_MARKDWN;
2342 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002343 ha_alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
Willy Tarreau272adea2014-03-31 10:39:59 +02002344 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2345 file, linenum, args[cur_arg], args[cur_arg + 1]);
2346 err_code |= ERR_ALERT | ERR_FATAL;
2347 goto out;
2348 }
2349
2350 cur_arg += 2;
2351 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002352 else if (strcmp(args[cur_arg], "on-marked-down") == 0) {
2353 if (strcmp(args[cur_arg + 1], "shutdown-sessions") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002354 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2355 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002356 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002357 file, linenum, args[cur_arg], args[cur_arg + 1]);
2358 err_code |= ERR_ALERT | ERR_FATAL;
2359 goto out;
2360 }
2361
2362 cur_arg += 2;
2363 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002364 else if (strcmp(args[cur_arg], "on-marked-up") == 0) {
2365 if (strcmp(args[cur_arg + 1], "shutdown-backup-sessions") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002366 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2367 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002368 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002369 file, linenum, args[cur_arg], args[cur_arg + 1]);
2370 err_code |= ERR_ALERT | ERR_FATAL;
2371 goto out;
2372 }
2373
2374 cur_arg += 2;
2375 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002376 else if (strcmp(args[cur_arg], "error-limit") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002377 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002378 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002379 file, linenum, args[cur_arg]);
2380 err_code |= ERR_ALERT | ERR_FATAL;
2381 goto out;
2382 }
2383
2384 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2385
2386 if (newsrv->consecutive_errors_limit <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002387 ha_alert("parsing [%s:%d]: %s has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002388 file, linenum, args[cur_arg]);
2389 err_code |= ERR_ALERT | ERR_FATAL;
2390 goto out;
2391 }
2392 cur_arg += 2;
2393 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002394 else if (strcmp(args[cur_arg], "usesrc") == 0) { /* address to use outside: needs "source" first */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002395 ha_alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002396 file, linenum, "usesrc", "source");
2397 err_code |= ERR_ALERT | ERR_FATAL;
2398 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002399 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002400 else {
2401 static int srv_dumped;
2402 struct srv_kw *kw;
2403 char *err;
2404
2405 kw = srv_find_kw(args[cur_arg]);
2406 if (kw) {
2407 char *err = NULL;
2408 int code;
2409
2410 if (!kw->parse) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002411 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not implemented in this version (check build options).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002412 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002413 if (kw->skip != -1)
2414 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002415 err_code |= ERR_ALERT | ERR_FATAL;
2416 goto out;
2417 }
2418
2419 if (defsrv && !kw->default_ok) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002420 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002421 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002422 if (kw->skip != -1)
2423 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002424 err_code |= ERR_ALERT;
2425 continue;
2426 }
2427
2428 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2429 err_code |= code;
2430
2431 if (code) {
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002432 display_parser_err(file, linenum, args, cur_arg, code, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002433 if (code & ERR_FATAL) {
2434 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002435 if (kw->skip != -1)
2436 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002437 goto out;
2438 }
2439 }
2440 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002441 if (kw->skip != -1)
2442 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002443 continue;
2444 }
2445
2446 err = NULL;
2447 if (!srv_dumped) {
2448 srv_dump_kws(&err);
2449 indent_msg(&err, 4);
2450 srv_dumped = 1;
2451 }
2452
Christopher Faulet767a84b2017-11-24 16:50:31 +01002453 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002454 file, linenum, args[0], args[1], args[cur_arg],
2455 err ? " Registered keywords :" : "", err ? err : "");
2456 free(err);
2457
2458 err_code |= ERR_ALERT | ERR_FATAL;
2459 goto out;
2460 }
2461 }
2462
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002463 if (!defsrv)
2464 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2465 if (err_code & ERR_FATAL)
2466 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002467 if (srv_tmpl)
2468 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002469 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002470 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002471 return 0;
2472
2473 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002474 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002475 free(errmsg);
2476 return err_code;
2477}
2478
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002479/* Returns a pointer to the first server matching either id <id>.
2480 * NULL is returned if no match is found.
2481 * the lookup is performed in the backend <bk>
2482 */
2483struct server *server_find_by_id(struct proxy *bk, int id)
2484{
2485 struct eb32_node *eb32;
2486 struct server *curserver;
2487
2488 if (!bk || (id ==0))
2489 return NULL;
2490
2491 /* <bk> has no backend capabilities, so it can't have a server */
2492 if (!(bk->cap & PR_CAP_BE))
2493 return NULL;
2494
2495 curserver = NULL;
2496
2497 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2498 if (eb32)
2499 curserver = container_of(eb32, struct server, conf.id);
2500
2501 return curserver;
2502}
2503
2504/* Returns a pointer to the first server matching either name <name>, or id
2505 * if <name> starts with a '#'. NULL is returned if no match is found.
2506 * the lookup is performed in the backend <bk>
2507 */
2508struct server *server_find_by_name(struct proxy *bk, const char *name)
2509{
2510 struct server *curserver;
2511
2512 if (!bk || !name)
2513 return NULL;
2514
2515 /* <bk> has no backend capabilities, so it can't have a server */
2516 if (!(bk->cap & PR_CAP_BE))
2517 return NULL;
2518
2519 curserver = NULL;
2520 if (*name == '#') {
2521 curserver = server_find_by_id(bk, atoi(name + 1));
2522 if (curserver)
2523 return curserver;
2524 }
2525 else {
2526 curserver = bk->srv;
2527
2528 while (curserver && (strcmp(curserver->id, name) != 0))
2529 curserver = curserver->next;
2530
2531 if (curserver)
2532 return curserver;
2533 }
2534
2535 return NULL;
2536}
2537
2538struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2539{
2540 struct server *byname;
2541 struct server *byid;
2542
2543 if (!name && !id)
2544 return NULL;
2545
2546 if (diff)
2547 *diff = 0;
2548
2549 byname = byid = NULL;
2550
2551 if (name) {
2552 byname = server_find_by_name(bk, name);
2553 if (byname && (!id || byname->puid == id))
2554 return byname;
2555 }
2556
2557 /* remaining possibilities :
2558 * - name not set
2559 * - name set but not found
2560 * - name found but ID doesn't match
2561 */
2562 if (id) {
2563 byid = server_find_by_id(bk, id);
2564 if (byid) {
2565 if (byname) {
2566 /* use id only if forced by configuration */
2567 if (byid->flags & SRV_F_FORCED_ID) {
2568 if (diff)
2569 *diff |= 2;
2570 return byid;
2571 }
2572 else {
2573 if (diff)
2574 *diff |= 1;
2575 return byname;
2576 }
2577 }
2578
2579 /* remaining possibilities:
2580 * - name not set
2581 * - name set but not found
2582 */
2583 if (name && diff)
2584 *diff |= 2;
2585 return byid;
2586 }
2587
2588 /* id bot found */
2589 if (byname) {
2590 if (diff)
2591 *diff |= 1;
2592 return byname;
2593 }
2594 }
2595
2596 return NULL;
2597}
2598
Willy Tarreau46b7f532018-08-21 11:54:26 +02002599/* Update a server state using the parameters available in the params list.
2600 *
2601 * Grabs the server lock during operation.
2602 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002603static void srv_update_state(struct server *srv, int version, char **params)
2604{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002605 char *p;
Willy Tarreau83061a82018-07-13 11:56:34 +02002606 struct buffer *msg;
William Dauchyd1a7b852021-02-11 22:51:26 +01002607 const char *warning;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002608
2609 /* fields since version 1
2610 * and common to all other upcoming versions
2611 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002612 enum srv_state srv_op_state;
2613 enum srv_admin srv_admin_state;
2614 unsigned srv_uweight, srv_iweight;
2615 unsigned long srv_last_time_change;
2616 short srv_check_status;
2617 enum chk_result srv_check_result;
2618 int srv_check_health;
2619 int srv_check_state, srv_agent_state;
2620 int bk_f_forced_id;
2621 int srv_f_forced_id;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002622 int fqdn_set_by_cli;
2623 const char *fqdn;
William Dauchyd1a7b852021-02-11 22:51:26 +01002624 const char *port_st;
William Dauchyfe03e7d2021-02-03 22:30:06 +01002625 unsigned int port_svc;
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002626 char *srvrecord;
William Dauchyd1a7b852021-02-11 22:51:26 +01002627 char *addr;
William Dauchyddc7ce92021-02-11 22:51:27 +01002628 int partial_apply = 0;
William Dauchyf6370442020-11-14 19:25:33 +01002629#ifdef USE_OPENSSL
2630 int use_ssl;
2631#endif
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002632
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002633 fqdn = NULL;
William Dauchyd1a7b852021-02-11 22:51:26 +01002634 port_svc = 0;
2635 msg = alloc_trash_chunk();
2636 if (!msg)
2637 goto end;
William Dauchy63e6cba2021-02-11 22:51:25 +01002638 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002639
William Dauchy63e6cba2021-02-11 22:51:25 +01002640 if (version >= 1) {
2641 /* srv_addr: params[0]
2642 * srv_op_state: params[1]
2643 * srv_admin_state: params[2]
2644 * srv_uweight: params[3]
2645 * srv_iweight: params[4]
2646 * srv_last_time_change: params[5]
2647 * srv_check_status: params[6]
2648 * srv_check_result: params[7]
2649 * srv_check_health: params[8]
2650 * srv_check_state: params[9]
2651 * srv_agent_state: params[10]
2652 * bk_f_forced_id: params[11]
2653 * srv_f_forced_id: params[12]
2654 * srv_fqdn: params[13]
2655 * srv_port: params[14]
2656 * srvrecord: params[15]
2657 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002658
William Dauchy63e6cba2021-02-11 22:51:25 +01002659 /* validating srv_op_state */
2660 p = NULL;
2661 errno = 0;
2662 srv_op_state = strtol(params[1], &p, 10);
2663 if ((p == params[1]) || errno == EINVAL || errno == ERANGE ||
2664 (srv_op_state != SRV_ST_STOPPED &&
2665 srv_op_state != SRV_ST_STARTING &&
2666 srv_op_state != SRV_ST_RUNNING &&
2667 srv_op_state != SRV_ST_STOPPING)) {
2668 chunk_appendf(msg, ", invalid srv_op_state value '%s'", params[1]);
2669 }
Willy Tarreau757478e2016-11-03 19:22:19 +01002670
William Dauchy63e6cba2021-02-11 22:51:25 +01002671 /* validating srv_admin_state */
2672 p = NULL;
2673 errno = 0;
2674 srv_admin_state = strtol(params[2], &p, 10);
2675 fqdn_set_by_cli = !!(srv_admin_state & SRV_ADMF_HMAINT);
Willy Tarreau757478e2016-11-03 19:22:19 +01002676
William Dauchy63e6cba2021-02-11 22:51:25 +01002677 /* inherited statuses will be recomputed later.
2678 * Also disable SRV_ADMF_HMAINT flag (set from stats socket fqdn).
2679 */
Christopher Fauleteaab7322021-02-12 17:36:08 +01002680 srv_admin_state &= ~SRV_ADMF_IDRAIN & ~SRV_ADMF_IMAINT & ~SRV_ADMF_HMAINT & ~SRV_ADMF_RMAINT;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002681
William Dauchy63e6cba2021-02-11 22:51:25 +01002682 if ((p == params[2]) || errno == EINVAL || errno == ERANGE ||
2683 (srv_admin_state != 0 &&
2684 srv_admin_state != SRV_ADMF_FMAINT &&
2685 srv_admin_state != SRV_ADMF_CMAINT &&
2686 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT) &&
2687 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FDRAIN) &&
2688 srv_admin_state != SRV_ADMF_FDRAIN)) {
2689 chunk_appendf(msg, ", invalid srv_admin_state value '%s'", params[2]);
2690 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002691
William Dauchy63e6cba2021-02-11 22:51:25 +01002692 /* validating srv_uweight */
2693 p = NULL;
2694 errno = 0;
2695 srv_uweight = strtol(params[3], &p, 10);
2696 if ((p == params[3]) || errno == EINVAL || errno == ERANGE || (srv_uweight > SRV_UWGHT_MAX))
2697 chunk_appendf(msg, ", invalid srv_uweight value '%s'", params[3]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002698
William Dauchy63e6cba2021-02-11 22:51:25 +01002699 /* validating srv_iweight */
2700 p = NULL;
2701 errno = 0;
2702 srv_iweight = strtol(params[4], &p, 10);
2703 if ((p == params[4]) || errno == EINVAL || errno == ERANGE || (srv_iweight > SRV_UWGHT_MAX))
2704 chunk_appendf(msg, ", invalid srv_iweight value '%s'", params[4]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002705
William Dauchy63e6cba2021-02-11 22:51:25 +01002706 /* validating srv_last_time_change */
2707 p = NULL;
2708 errno = 0;
2709 srv_last_time_change = strtol(params[5], &p, 10);
2710 if ((p == params[5]) || errno == EINVAL || errno == ERANGE)
2711 chunk_appendf(msg, ", invalid srv_last_time_change value '%s'", params[5]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002712
William Dauchy63e6cba2021-02-11 22:51:25 +01002713 /* validating srv_check_status */
2714 p = NULL;
2715 errno = 0;
2716 srv_check_status = strtol(params[6], &p, 10);
2717 if (p == params[6] || errno == EINVAL || errno == ERANGE ||
2718 (srv_check_status >= HCHK_STATUS_SIZE))
2719 chunk_appendf(msg, ", invalid srv_check_status value '%s'", params[6]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002720
William Dauchy63e6cba2021-02-11 22:51:25 +01002721 /* validating srv_check_result */
2722 p = NULL;
2723 errno = 0;
2724 srv_check_result = strtol(params[7], &p, 10);
2725 if ((p == params[7]) || errno == EINVAL || errno == ERANGE ||
2726 (srv_check_result != CHK_RES_UNKNOWN &&
2727 srv_check_result != CHK_RES_NEUTRAL &&
2728 srv_check_result != CHK_RES_FAILED &&
2729 srv_check_result != CHK_RES_PASSED &&
2730 srv_check_result != CHK_RES_CONDPASS)) {
2731 chunk_appendf(msg, ", invalid srv_check_result value '%s'", params[7]);
2732 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002733
William Dauchy63e6cba2021-02-11 22:51:25 +01002734 /* validating srv_check_health */
2735 p = NULL;
2736 errno = 0;
2737 srv_check_health = strtol(params[8], &p, 10);
2738 if (p == params[8] || errno == EINVAL || errno == ERANGE)
2739 chunk_appendf(msg, ", invalid srv_check_health value '%s'", params[8]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002740
William Dauchy63e6cba2021-02-11 22:51:25 +01002741 /* validating srv_check_state */
2742 p = NULL;
2743 errno = 0;
2744 srv_check_state = strtol(params[9], &p, 10);
2745 if (p == params[9] || errno == EINVAL || errno == ERANGE ||
2746 (srv_check_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2747 chunk_appendf(msg, ", invalid srv_check_state value '%s'", params[9]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002748
William Dauchy63e6cba2021-02-11 22:51:25 +01002749 /* validating srv_agent_state */
2750 p = NULL;
2751 errno = 0;
2752 srv_agent_state = strtol(params[10], &p, 10);
2753 if (p == params[10] || errno == EINVAL || errno == ERANGE ||
2754 (srv_agent_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2755 chunk_appendf(msg, ", invalid srv_agent_state value '%s'", params[10]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002756
William Dauchy63e6cba2021-02-11 22:51:25 +01002757 /* validating bk_f_forced_id */
2758 p = NULL;
2759 errno = 0;
2760 bk_f_forced_id = strtol(params[11], &p, 10);
2761 if (p == params[11] || errno == EINVAL || errno == ERANGE || !((bk_f_forced_id == 0) || (bk_f_forced_id == 1)))
2762 chunk_appendf(msg, ", invalid bk_f_forced_id value '%s'", params[11]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002763
William Dauchy63e6cba2021-02-11 22:51:25 +01002764 /* validating srv_f_forced_id */
2765 p = NULL;
2766 errno = 0;
2767 srv_f_forced_id = strtol(params[12], &p, 10);
2768 if (p == params[12] || errno == EINVAL || errno == ERANGE || !((srv_f_forced_id == 0) || (srv_f_forced_id == 1)))
2769 chunk_appendf(msg, ", invalid srv_f_forced_id value '%s'", params[12]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002770
William Dauchy63e6cba2021-02-11 22:51:25 +01002771 /* validating srv_fqdn */
2772 fqdn = params[13];
2773 if (fqdn && *fqdn == '-')
2774 fqdn = NULL;
2775 if (fqdn && (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn))) {
2776 chunk_appendf(msg, ", invalid srv_fqdn value '%s'", params[13]);
2777 fqdn = NULL;
2778 }
Frédéric Lécaille31694712017-08-01 08:47:19 +02002779
William Dauchyd1a7b852021-02-11 22:51:26 +01002780 port_st = params[14];
2781 if (port_st) {
2782 port_svc = strl2uic(port_st, strlen(port_st));
William Dauchy63e6cba2021-02-11 22:51:25 +01002783 if (port_svc > USHRT_MAX) {
William Dauchyd1a7b852021-02-11 22:51:26 +01002784 chunk_appendf(msg, ", invalid srv_port value '%s'", port_st);
2785 port_st = NULL;
William Dauchy63e6cba2021-02-11 22:51:25 +01002786 }
2787 }
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002788
William Dauchy63e6cba2021-02-11 22:51:25 +01002789 /* SRV record
2790 * NOTE: in HAProxy, SRV records must start with an underscore '_'
2791 */
2792 srvrecord = params[15];
2793 if (srvrecord && *srvrecord != '_')
2794 srvrecord = NULL;
William Dauchyf6370442020-11-14 19:25:33 +01002795
William Dauchy63e6cba2021-02-11 22:51:25 +01002796 /* don't apply anything if one error has been detected */
2797 if (msg->data)
2798 goto out;
William Dauchyddc7ce92021-02-11 22:51:27 +01002799 partial_apply = 1;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002800
William Dauchy63e6cba2021-02-11 22:51:25 +01002801 /* recover operational state and apply it to this server
2802 * and all servers tracking this one */
2803 srv->check.health = srv_check_health;
2804 switch (srv_op_state) {
2805 case SRV_ST_STOPPED:
2806 srv->check.health = 0;
2807 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
2808 break;
2809 case SRV_ST_STARTING:
2810 /* If rise == 1 there is no STARTING state, let's switch to
2811 * RUNNING
2812 */
2813 if (srv->check.rise == 1) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002814 srv->check.health = srv->check.rise + srv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02002815 srv_set_running(srv, "", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002816 break;
William Dauchy63e6cba2021-02-11 22:51:25 +01002817 }
2818 if (srv->check.health < 1 || srv->check.health >= srv->check.rise)
2819 srv->check.health = srv->check.rise - 1;
2820 srv->next_state = srv_op_state;
2821 break;
2822 case SRV_ST_STOPPING:
2823 /* If fall == 1 there is no STOPPING state, let's switch to
2824 * STOPPED
2825 */
2826 if (srv->check.fall == 1) {
2827 srv->check.health = 0;
2828 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
2829 break;
2830 }
2831 if (srv->check.health < srv->check.rise ||
2832 srv->check.health > srv->check.rise + srv->check.fall - 2)
2833 srv->check.health = srv->check.rise;
2834 srv_set_stopping(srv, "changed from server-state after a reload", NULL);
2835 break;
2836 case SRV_ST_RUNNING:
2837 srv->check.health = srv->check.rise + srv->check.fall - 1;
2838 srv_set_running(srv, "", NULL);
2839 break;
2840 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002841
William Dauchy63e6cba2021-02-11 22:51:25 +01002842 /* When applying server state, the following rules apply:
2843 * - in case of a configuration change, we apply the setting from the new
2844 * configuration, regardless of old running state
2845 * - if no configuration change, we apply old running state only if old running
2846 * state is different from new configuration state
2847 */
2848 /* configuration has changed */
2849 if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->next_admin & SRV_ADMF_CMAINT)) {
2850 if (srv->next_admin & SRV_ADMF_CMAINT)
2851 srv_adm_set_maint(srv);
2852 else
2853 srv_adm_set_ready(srv);
2854 }
2855 /* configuration is the same, let's compate old running state and new conf state */
2856 else {
2857 if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->next_admin & SRV_ADMF_CMAINT))
2858 srv_adm_set_maint(srv);
2859 else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->next_admin & SRV_ADMF_CMAINT))
2860 srv_adm_set_ready(srv);
2861 }
2862 /* apply drain mode if server is currently enabled */
2863 if (!(srv->next_admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) {
2864 /* The SRV_ADMF_FDRAIN flag is inherited when srv->iweight is 0
2865 * (srv->iweight is the weight set up in configuration).
2866 * There are two possible reasons for FDRAIN to have been present :
2867 * - previous config weight was zero
2868 * - "set server b/s drain" was sent to the CLI
2869 *
2870 * In the first case, we simply want to drop this drain state
2871 * if the new weight is not zero anymore, meaning the administrator
2872 * has intentionally turned the weight back to a positive value to
2873 * enable the server again after an operation. In the second case,
2874 * the drain state was forced on the CLI regardless of the config's
2875 * weight so we don't want a change to the config weight to lose this
2876 * status. What this means is :
2877 * - if previous weight was 0 and new one is >0, drop the DRAIN state.
2878 * - if the previous weight was >0, keep it.
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002879 */
William Dauchy63e6cba2021-02-11 22:51:25 +01002880 if (srv_iweight > 0 || srv->iweight == 0)
2881 srv_adm_set_drain(srv);
2882 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002883
William Dauchy63e6cba2021-02-11 22:51:25 +01002884 srv->last_change = date.tv_sec - srv_last_time_change;
2885 srv->check.status = srv_check_status;
2886 srv->check.result = srv_check_result;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002887
William Dauchy63e6cba2021-02-11 22:51:25 +01002888 /* Only case we want to apply is removing ENABLED flag which could have been
2889 * done by the "disable health" command over the stats socket
2890 */
2891 if ((srv->check.state & CHK_ST_CONFIGURED) &&
2892 (srv_check_state & CHK_ST_CONFIGURED) &&
2893 !(srv_check_state & CHK_ST_ENABLED))
2894 srv->check.state &= ~CHK_ST_ENABLED;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002895
William Dauchy63e6cba2021-02-11 22:51:25 +01002896 /* Only case we want to apply is removing ENABLED flag which could have been
2897 * done by the "disable agent" command over the stats socket
2898 */
2899 if ((srv->agent.state & CHK_ST_CONFIGURED) &&
2900 (srv_agent_state & CHK_ST_CONFIGURED) &&
2901 !(srv_agent_state & CHK_ST_ENABLED))
2902 srv->agent.state &= ~CHK_ST_ENABLED;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002903
William Dauchy63e6cba2021-02-11 22:51:25 +01002904 /* We want to apply the previous 'running' weight (srv_uweight) only if there
2905 * was no change in the configuration: both previous and new iweight are equals
2906 *
2907 * It means that a configuration file change has precedence over a unix socket change
2908 * for server's weight
2909 *
2910 * by default, HAProxy applies the following weight when parsing the configuration
2911 * srv->uweight = srv->iweight
2912 */
2913 if (srv_iweight == srv->iweight) {
2914 srv->uweight = srv_uweight;
2915 }
2916 server_recalc_eweight(srv, 1);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002917
William Dauchy63e6cba2021-02-11 22:51:25 +01002918 /* load server IP address */
2919 if (strcmp(params[0], "-") != 0)
2920 srv->lastaddr = strdup(params[0]);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002921
William Dauchy63e6cba2021-02-11 22:51:25 +01002922 if (fqdn && srv->hostname) {
2923 if (strcmp(srv->hostname, fqdn) == 0) {
2924 /* Here we reset the 'set from stats socket FQDN' flag
2925 * to support such transitions:
2926 * Let's say initial FQDN value is foo1 (in configuration file).
2927 * - FQDN changed from stats socket, from foo1 to foo2 value,
2928 * - FQDN changed again from file configuration (with the same previous value
2929 set from stats socket, from foo1 to foo2 value),
2930 * - reload for any other reason than a FQDN modification,
2931 * the configuration file FQDN matches the fqdn server state file value.
2932 * So we must reset the 'set from stats socket FQDN' flag to be consistent with
2933 * any further FQDN modification.
2934 */
2935 srv->next_admin &= ~SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002936 }
William Dauchy63e6cba2021-02-11 22:51:25 +01002937 else {
2938 /* If the FDQN has been changed from stats socket,
2939 * apply fqdn state file value (which is the value set
2940 * from stats socket).
2941 * Also ensure the runtime resolver will process this resolution.
2942 */
2943 if (fqdn_set_by_cli) {
2944 srv_set_fqdn(srv, fqdn, 0);
2945 srv->flags &= ~SRV_F_NO_RESOLUTION;
2946 srv->next_admin |= SRV_ADMF_HMAINT;
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002947 }
William Dauchy63e6cba2021-02-11 22:51:25 +01002948 }
2949 }
2950 /* If all the conditions below are validated, this means
2951 * we're evaluating a server managed by SRV resolution
2952 */
2953 else if (fqdn && !srv->hostname && srvrecord) {
2954 int res;
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002955
William Dauchy63e6cba2021-02-11 22:51:25 +01002956 /* we can't apply previous state if SRV record has changed */
2957 if (srv->srvrq && strcmp(srv->srvrq->name, srvrecord) != 0) {
2958 chunk_appendf(msg, ", SRV record mismatch between configuration ('%s') and state file ('%s) for server '%s'. Previous state not applied", srv->srvrq->name, srvrecord, srv->id);
2959 goto out;
2960 }
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002961
William Dauchy63e6cba2021-02-11 22:51:25 +01002962 /* create or find a SRV resolution for this srv record */
2963 if (srv->srvrq == NULL && (srv->srvrq = find_srvrq_by_name(srvrecord, srv->proxy)) == NULL)
Emeric Brun08622d32020-12-23 17:41:43 +01002964 srv->srvrq = new_resolv_srvrq(srv, srvrecord);
William Dauchy63e6cba2021-02-11 22:51:25 +01002965 if (srv->srvrq == NULL) {
2966 chunk_appendf(msg, ", can't create or find SRV resolution '%s' for server '%s'", srvrecord, srv->id);
2967 goto out;
2968 }
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002969
William Dauchy63e6cba2021-02-11 22:51:25 +01002970 /* prepare DNS resolution for this server */
2971 res = srv_prepare_for_resolution(srv, fqdn);
2972 if (res == -1) {
2973 chunk_appendf(msg, ", can't allocate memory for DNS resolution for server '%s'", srv->id);
2974 goto out;
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002975 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002976
William Dauchy63e6cba2021-02-11 22:51:25 +01002977 /* Unset SRV_F_MAPPORTS for SRV records.
2978 * SRV_F_MAPPORTS is unfortunately set by parse_server()
2979 * because no ports are provided in the configuration file.
2980 * This is because HAProxy will use the port found into the SRV record.
2981 */
2982 srv->flags &= ~SRV_F_MAPPORTS;
2983 }
2984
William Dauchyd1a7b852021-02-11 22:51:26 +01002985 if (port_st)
William Dauchy63e6cba2021-02-11 22:51:25 +01002986 srv->svc_port = port_svc;
William Dauchyfe03e7d2021-02-03 22:30:06 +01002987
William Dauchy63e6cba2021-02-11 22:51:25 +01002988 }
2989 if (version >= 2) {
2990 /* srv_use_ssl: params[16]
2991 * srv_check_port: params[17]
William Dauchyd1a7b852021-02-11 22:51:26 +01002992 * srv_check_addr: params[18]
2993 * srv_agent_addr: params[19]
2994 * srv_agent_port: params[20]
William Dauchy63e6cba2021-02-11 22:51:25 +01002995 */
William Dauchyf6370442020-11-14 19:25:33 +01002996
2997#ifdef USE_OPENSSL
William Dauchy63e6cba2021-02-11 22:51:25 +01002998 use_ssl = strtol(params[16], &p, 10);
William Dauchyf6370442020-11-14 19:25:33 +01002999
William Dauchy63e6cba2021-02-11 22:51:25 +01003000 /* configure ssl if connection has been initiated at startup */
3001 if (srv->ssl_ctx.ctx != NULL)
3002 ssl_sock_set_srv(srv, use_ssl);
3003#endif
William Dauchyd1a7b852021-02-11 22:51:26 +01003004 port_st = NULL;
3005 if (strcmp(params[17], "0") != 0)
3006 port_st = params[17];
3007 addr = NULL;
3008 if (strcmp(params[18], "-") != 0)
3009 addr = params[18];
3010 if (addr || port_st) {
3011 warning = update_server_check_addr_port(srv, addr, port_st);
3012 if (warning) {
3013 chunk_appendf(msg, ", %s", warning);
3014 goto out;
3015 }
3016 }
Frédéric Lécaille31694712017-08-01 08:47:19 +02003017
William Dauchyd1a7b852021-02-11 22:51:26 +01003018 port_st = NULL;
3019 if (strcmp(params[17], "0") != 0)
3020 port_st = params[20];
3021 addr = NULL;
3022 if (strcmp(params[19], "-") != 0)
3023 addr = params[19];
3024 if (addr || port_st) {
3025 warning = update_server_agent_addr_port(srv, addr, port_st);
3026 if (warning) {
3027 chunk_appendf(msg, ", %s", warning);
3028 goto out;
3029 }
3030 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003031 }
3032
3033 out:
William Dauchy63e6cba2021-02-11 22:51:25 +01003034 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003035 if (msg->data) {
William Dauchyddc7ce92021-02-11 22:51:27 +01003036 if (partial_apply == 1)
3037 ha_warning("server-state partially applied for server '%s/%s'%s\n",
3038 srv->proxy->id, srv->id, msg->area);
3039 else
3040 ha_warning("server-state application failed for server '%s/%s'%s\n",
3041 srv->proxy->id, srv->id, msg->area);
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003042 }
William Dauchyd1a7b852021-02-11 22:51:26 +01003043 end:
3044 free_trash_chunk(msg);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003045}
3046
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003047
3048/*
3049 * read next line from file <f> and return the server state version if one found.
3050 * If no version is found, then 0 is returned
3051 * Note that this should be the first read on <f>
3052 */
3053static int srv_state_get_version(FILE *f) {
3054 char buf[2];
3055 int ret;
3056
3057 /* first character of first line of the file must contain the version of the export */
3058 if (fgets(buf, 2, f) == NULL) {
3059 return 0;
3060 }
3061
3062 ret = atoi(buf);
3063 if ((ret < SRV_STATE_FILE_VERSION_MIN) ||
3064 (ret > SRV_STATE_FILE_VERSION_MAX))
3065 return 0;
3066
3067 return ret;
3068}
3069
3070
3071/*
3072 * parses server state line stored in <buf> and supposedly in version <version>.
3073 * Set <params> and <srv_params> accordingly.
3074 * In case of error, params[0] is set to NULL.
3075 */
3076static void srv_state_parse_line(char *buf, const int version, char **params, char **srv_params)
3077{
3078 int buflen, arg, srv_arg;
3079 char *cur, *end;
3080
3081 buflen = strlen(buf);
3082 cur = buf;
3083 end = cur + buflen;
3084
3085 /* we need at least one character */
3086 if (buflen == 0) {
3087 params[0] = NULL;
3088 return;
3089 }
3090
3091 /* ignore blank characters at the beginning of the line */
Willy Tarreau90807112020-02-25 08:16:33 +01003092 while (isspace((unsigned char)*cur))
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003093 ++cur;
3094
3095 /* Ignore empty or commented lines */
3096 if (cur == end || *cur == '#') {
3097 params[0] = NULL;
3098 return;
3099 }
3100
3101 /* truncated lines */
3102 if (buf[buflen - 1] != '\n') {
3103 //ha_warning("server-state file '%s': truncated line\n", filepath);
3104 params[0] = NULL;
3105 return;
3106 }
3107
3108 /* Removes trailing '\n' */
3109 buf[buflen - 1] = '\0';
3110
3111 /* we're now ready to move the line into *srv_params[] */
3112 params[0] = cur;
3113 arg = 1;
3114 srv_arg = 0;
3115 while (*cur && arg < SRV_STATE_FILE_MAX_FIELDS) {
Willy Tarreau90807112020-02-25 08:16:33 +01003116 if (isspace((unsigned char)*cur)) {
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003117 *cur = '\0';
3118 ++cur;
Willy Tarreau90807112020-02-25 08:16:33 +01003119 while (isspace((unsigned char)*cur))
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003120 ++cur;
William Dauchy63e6cba2021-02-11 22:51:25 +01003121
3122 /* v1
3123 * srv_addr: params[4] => srv_params[0]
3124 * srv_op_state: params[5] => srv_params[1]
3125 * srv_admin_state: params[6] => srv_params[2]
3126 * srv_uweight: params[7] => srv_params[3]
3127 * srv_iweight: params[8] => srv_params[4]
3128 * srv_last_time_change: params[9] => srv_params[5]
3129 * srv_check_status: params[10] => srv_params[6]
3130 * srv_check_result: params[11] => srv_params[7]
3131 * srv_check_health: params[12] => srv_params[8]
3132 * srv_check_state: params[13] => srv_params[9]
3133 * srv_agent_state: params[14] => srv_params[10]
3134 * bk_f_forced_id: params[15] => srv_params[11]
3135 * srv_f_forced_id: params[16] => srv_params[12]
3136 * srv_fqdn: params[17] => srv_params[13]
3137 * srv_port: params[18] => srv_params[14]
3138 * srvrecord: params[19] => srv_params[15]
3139 * v2
3140 * srv_use_ssl: params[20] => srv_params[16]
3141 * srv_check_port: params[21] => srv_params[17]
William Dauchyd1a7b852021-02-11 22:51:26 +01003142 * srv_check_addr: params[22] => srv_params[18]
3143 * srv_agent_addr: params[23] => srv_params[19]
3144 * srv_agent_port: params[24] => srv_params[20]
William Dauchy63e6cba2021-02-11 22:51:25 +01003145 */
3146 if ((version == 1 && arg >= 4 && arg <= 19) ||
3147 (version == 2 && arg >= 4)) {
3148 srv_params[srv_arg] = cur;
3149 ++srv_arg;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003150 }
3151
3152 params[arg] = cur;
3153 ++arg;
3154 }
3155 else {
3156 ++cur;
3157 }
3158 }
3159
3160 /* if line is incomplete line, then ignore it.
3161 * otherwise, update useful flags */
William Dauchy63e6cba2021-02-11 22:51:25 +01003162 if ((version == 1 && arg < SRV_STATE_FILE_NB_FIELDS_VERSION_1) ||
3163 (version == 2 && arg < SRV_STATE_FILE_NB_FIELDS_VERSION_2))
3164 params[0] = NULL;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003165}
3166
3167
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003168/* This function parses all the proxies and only take care of the backends (since we're looking for server)
3169 * For each proxy, it does the following:
3170 * - opens its server state file (either one or local one)
3171 * - read whole file, line by line
3172 * - analyse each line to check if it matches our current backend:
3173 * - backend name matches
3174 * - backend id matches if id is forced and name doesn't match
3175 * - if the server pointed by the line is found, then state is applied
3176 *
3177 * If the running backend uuid or id differs from the state file, then HAProxy reports
3178 * a warning.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003179 *
3180 * Grabs the server's lock via srv_update_state().
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003181 */
3182void apply_server_state(void)
3183{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003184 char mybuf[SRV_STATE_LINE_MAXLEN];
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003185 char *params[SRV_STATE_FILE_MAX_FIELDS] = {0};
3186 char *srv_params[SRV_STATE_FILE_MAX_FIELDS] = {0};
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003187 int version, global_file_version;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003188 FILE *f;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003189 char globalfilepath[MAXPATHLEN + 1];
3190 char localfilepath[MAXPATHLEN + 1];
3191 int len, fileopenerr, globalfilepathlen, localfilepathlen;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003192 struct proxy *curproxy, *bk;
3193 struct server *srv;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003194 char *line;
3195 char *bkname, *srvname;
3196 struct state_line *st;
3197 struct ebmb_node *node, *next_node;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003198
Willy Tarreau2d067f92020-07-16 06:40:27 +02003199 f = NULL;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003200 global_file_version = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003201 globalfilepathlen = 0;
3202 /* create the globalfilepath variable */
3203 if (global.server_state_file) {
3204 /* absolute path or no base directory provided */
3205 if ((global.server_state_file[0] == '/') || (!global.server_state_base)) {
3206 len = strlen(global.server_state_file);
3207 if (len > MAXPATHLEN) {
3208 globalfilepathlen = 0;
3209 goto globalfileerror;
3210 }
3211 memcpy(globalfilepath, global.server_state_file, len);
3212 globalfilepath[len] = '\0';
3213 globalfilepathlen = len;
3214 }
3215 else if (global.server_state_base) {
3216 len = strlen(global.server_state_base);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003217 if (len > MAXPATHLEN) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003218 globalfilepathlen = 0;
3219 goto globalfileerror;
3220 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003221 memcpy(globalfilepath, global.server_state_base, len);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003222 globalfilepath[len] = 0;
3223 globalfilepathlen = len;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003224
3225 /* append a slash if needed */
3226 if (!globalfilepathlen || globalfilepath[globalfilepathlen - 1] != '/') {
3227 if (globalfilepathlen + 1 > MAXPATHLEN) {
3228 globalfilepathlen = 0;
3229 goto globalfileerror;
3230 }
3231 globalfilepath[globalfilepathlen++] = '/';
3232 }
3233
3234 len = strlen(global.server_state_file);
3235 if (globalfilepathlen + len > MAXPATHLEN) {
3236 globalfilepathlen = 0;
3237 goto globalfileerror;
3238 }
3239 memcpy(globalfilepath + globalfilepathlen, global.server_state_file, len);
3240 globalfilepathlen += len;
3241 globalfilepath[globalfilepathlen++] = 0;
3242 }
3243 }
3244 globalfileerror:
3245 if (globalfilepathlen == 0)
3246 globalfilepath[0] = '\0';
3247
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003248 /* Load global server state in a tree */
3249 if (globalfilepathlen > 0) {
3250 errno = 0;
3251 f = fopen(globalfilepath, "r");
3252 if (errno)
3253 ha_warning("Can't open global server state file '%s': %s\n", globalfilepath, strerror(errno));
Vedran Furac5d486272019-10-16 14:49:38 +02003254 if (!f)
3255 goto out_load_server_state_in_tree;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003256
3257 global_file_version = srv_state_get_version(f);
3258 if (global_file_version == 0)
3259 goto out_load_server_state_in_tree;
3260
3261 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3262 line = NULL;
3263
3264 line = strdup(mybuf);
3265 if (line == NULL)
3266 continue;
3267
3268 srv_state_parse_line(mybuf, global_file_version, params, srv_params);
3269 if (params[0] == NULL)
Willy Tarreauca7a5af2019-12-20 17:26:27 +01003270 goto nextline;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003271
3272 /* bkname */
3273 bkname = params[1];
3274 /* srvname */
3275 srvname = params[3];
3276
3277 /* key */
3278 chunk_printf(&trash, "%s %s", bkname, srvname);
3279
3280 /* store line in tree */
Willy Tarreau7d6a1fa2019-12-20 17:18:13 +01003281 st = calloc(1, sizeof(*st) + trash.data + 1);
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003282 if (st == NULL) {
3283 goto nextline;
3284 }
Willy Tarreau7d6a1fa2019-12-20 17:18:13 +01003285 memcpy(st->name_name.key, trash.area, trash.data + 1);
Willy Tarreaufd1aa012019-12-20 17:23:40 +01003286 if (ebst_insert(&state_file, &st->name_name) != &st->name_name) {
3287 /* this is a duplicate key, probably a hand-crafted file,
3288 * drop it!
3289 */
3290 goto nextline;
3291 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003292
3293 /* save line */
3294 st->line = line;
3295
3296 continue;
3297
3298 nextline:
3299 /* free up memory in case of error during the processing of the line */
3300 free(line);
3301 }
3302 }
3303 out_load_server_state_in_tree:
3304
Ilya Shipitsindc6e8a92020-07-16 02:02:40 +05003305 if (f) {
3306 fclose(f);
3307 f = NULL;
3308 }
3309
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003310 /* parse all proxies and load states form tree (global file) or from local file */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003311 for (curproxy = proxies_list; curproxy != NULL; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003312 /* servers are only in backends */
3313 if (!(curproxy->cap & PR_CAP_BE))
3314 continue;
3315 fileopenerr = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003316
3317 /* search server state file path and name */
3318 switch (curproxy->load_server_state_from_file) {
3319 /* read servers state from global file */
3320 case PR_SRV_STATE_FILE_GLOBAL:
3321 /* there was an error while generating global server state file path */
3322 if (globalfilepathlen == 0)
3323 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003324 fileopenerr = 1;
3325 break;
3326 /* this backend has its own file */
3327 case PR_SRV_STATE_FILE_LOCAL:
3328 localfilepathlen = 0;
3329 localfilepath[0] = '\0';
3330 len = 0;
3331 /* create the localfilepath variable */
3332 /* absolute path or no base directory provided */
3333 if ((curproxy->server_state_file_name[0] == '/') || (!global.server_state_base)) {
3334 len = strlen(curproxy->server_state_file_name);
3335 if (len > MAXPATHLEN) {
3336 localfilepathlen = 0;
3337 goto localfileerror;
3338 }
3339 memcpy(localfilepath, curproxy->server_state_file_name, len);
3340 localfilepath[len] = '\0';
3341 localfilepathlen = len;
3342 }
3343 else if (global.server_state_base) {
3344 len = strlen(global.server_state_base);
3345 localfilepathlen += len;
3346
3347 if (localfilepathlen > MAXPATHLEN) {
3348 localfilepathlen = 0;
3349 goto localfileerror;
3350 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003351 memcpy(localfilepath, global.server_state_base, len);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003352 localfilepath[localfilepathlen] = 0;
3353
3354 /* append a slash if needed */
3355 if (!localfilepathlen || localfilepath[localfilepathlen - 1] != '/') {
3356 if (localfilepathlen + 1 > MAXPATHLEN) {
3357 localfilepathlen = 0;
3358 goto localfileerror;
3359 }
3360 localfilepath[localfilepathlen++] = '/';
3361 }
3362
3363 len = strlen(curproxy->server_state_file_name);
3364 if (localfilepathlen + len > MAXPATHLEN) {
3365 localfilepathlen = 0;
3366 goto localfileerror;
3367 }
3368 memcpy(localfilepath + localfilepathlen, curproxy->server_state_file_name, len);
3369 localfilepathlen += len;
3370 localfilepath[localfilepathlen++] = 0;
3371 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003372 localfileerror:
3373 if (localfilepathlen == 0)
Christopher Faulet8952ea62021-02-12 16:31:03 +01003374 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003375
3376 break;
3377 case PR_SRV_STATE_FILE_NONE:
3378 default:
3379 continue;
3380 }
3381
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003382 /* when global file is used, we get data from the tree
3383 * Note that in such case we don't check backend name neither uuid.
3384 * Backend name can't be wrong since it's used as a key to retrieve the server state
3385 * line from the tree.
3386 */
3387 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_GLOBAL) {
3388 struct server *srv = curproxy->srv;
3389 while (srv) {
3390 struct ebmb_node *node;
3391 struct state_line *st;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003392
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003393 chunk_printf(&trash, "%s %s", curproxy->id, srv->id);
3394 node = ebst_lookup(&state_file, trash.area);
3395 if (!node)
3396 goto next;
Dragan Dosencf4fb032015-11-04 23:03:26 +01003397
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003398 st = container_of(node, struct state_line, name_name);
3399 memcpy(mybuf, st->line, strlen(st->line));
3400 mybuf[strlen(st->line)] = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003401
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003402 srv_state_parse_line(mybuf, global_file_version, params, srv_params);
3403 if (params[0] == NULL)
3404 goto next;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003405
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003406 srv_update_state(srv, global_file_version, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003407
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003408 next:
3409 srv = srv->next;
3410 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003411
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003412 continue; /* next proxy in list */
3413 }
3414 else {
3415 /* load 'local' state file */
3416 errno = 0;
Christopher Faulet46967642021-02-12 16:38:14 +01003417 f = fopen(localfilepath, "r");
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003418 if (errno && fileopenerr)
Christopher Faulet46967642021-02-12 16:38:14 +01003419 ha_warning("Can't open server state file '%s': %s\n", localfilepath, strerror(errno));
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003420 if (!f)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003421 continue;
3422
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003423 mybuf[0] = '\0';
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003424
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003425 /* first character of first line of the file must contain the version of the export */
3426 version = srv_state_get_version(f);
3427 if (version == 0) {
Christopher Faulet46967642021-02-12 16:38:14 +01003428 ha_warning("Can't get version of the server state file '%s'\n", localfilepath);
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003429 goto fileclose;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003430 }
3431
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003432 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3433 int bk_f_forced_id = 0;
3434 int check_id = 0;
3435 int check_name = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003436
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003437 srv_state_parse_line(mybuf, version, params, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003438
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003439 if (params[0] == NULL) {
3440 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003441 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003442
3443 /* if line is incomplete line, then ignore it.
3444 * otherwise, update useful flags */
3445 switch (version) {
3446 case 1:
William Dauchy63e6cba2021-02-11 22:51:25 +01003447 case 2:
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003448 bk_f_forced_id = (atoi(params[15]) & PR_O_FORCED_ID);
3449 check_id = (atoi(params[0]) == curproxy->uuid);
3450 check_name = (strcmp(curproxy->id, params[1]) == 0);
3451 break;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003452 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003453
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003454 bk = curproxy;
3455
3456 /* if backend can't be found, let's continue */
3457 if (!check_id && !check_name)
3458 continue;
3459 else if (!check_id && check_name) {
3460 ha_warning("backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3461 send_log(bk, LOG_NOTICE, "backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3462 }
3463 else if (check_id && !check_name) {
3464 ha_warning("backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3465 send_log(bk, LOG_NOTICE, "backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3466 /* if name doesn't match, we still want to update curproxy if the backend id
3467 * was forced in previous the previous configuration */
3468 if (!bk_f_forced_id)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003469 continue;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003470 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003471
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003472 /* look for the server by its name: param[3] */
3473 srv = server_find_best_match(bk, params[3], 0, NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003474
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003475 if (!srv) {
3476 /* if no server found, then warning and continue with next line */
3477 ha_warning("can't find server '%s' in backend '%s'\n",
3478 params[3], params[1]);
3479 send_log(bk, LOG_NOTICE, "can't find server '%s' in backend '%s'\n",
3480 params[3], params[1]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003481 continue;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003482 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003483
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003484 /* now we can proceed with server's state update */
3485 srv_update_state(srv, version, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003486 }
Ilya Shipitsindc6e8a92020-07-16 02:02:40 +05003487
3488 fileclose:
3489 fclose(f);
3490
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003491 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003492 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003493
3494 /* now free memory allocated for the tree */
3495 for (node = ebmb_first(&state_file), next_node = node ? ebmb_next(node) : NULL;
3496 node;
3497 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
3498 st = container_of(node, struct state_line, name_name);
3499 ebmb_delete(&st->name_name);
3500 free(st->line);
3501 free(st);
3502 }
3503
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003504}
3505
Simon Horman7d09b9a2013-02-12 10:45:51 +09003506/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02003507 * update a server's current IP address.
3508 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
3509 * ip is in network format.
3510 * updater is a string which contains an information about the requester of the update.
3511 * updater is used if not NULL.
3512 *
3513 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003514 *
3515 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02003516 */
Thierry Fournierd35b7a62016-02-24 08:23:22 +01003517int update_server_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02003518{
Christopher Fauletd6c6b5f2020-09-08 10:27:24 +02003519 /* save the new IP family & address if necessary */
3520 switch (ip_sin_family) {
3521 case AF_INET:
3522 if (s->addr.ss_family == ip_sin_family &&
3523 !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
3524 return 0;
3525 break;
3526 case AF_INET6:
3527 if (s->addr.ss_family == ip_sin_family &&
3528 !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
3529 return 0;
3530 break;
3531 };
3532
Baptiste Assmann14e40142015-04-14 01:13:07 +02003533 /* generates a log line and a warning on stderr */
3534 if (1) {
3535 /* book enough space for both IPv4 and IPv6 */
3536 char oldip[INET6_ADDRSTRLEN];
3537 char newip[INET6_ADDRSTRLEN];
3538
3539 memset(oldip, '\0', INET6_ADDRSTRLEN);
3540 memset(newip, '\0', INET6_ADDRSTRLEN);
3541
3542 /* copy old IP address in a string */
3543 switch (s->addr.ss_family) {
3544 case AF_INET:
3545 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
3546 break;
3547 case AF_INET6:
3548 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
3549 break;
Christopher Fauletb0b76072020-09-08 10:38:40 +02003550 default:
3551 strcpy(oldip, "(none)");
3552 break;
Baptiste Assmann14e40142015-04-14 01:13:07 +02003553 };
3554
3555 /* copy new IP address in a string */
3556 switch (ip_sin_family) {
3557 case AF_INET:
3558 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
3559 break;
3560 case AF_INET6:
3561 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
3562 break;
3563 };
3564
3565 /* save log line into a buffer */
3566 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
3567 s->proxy->id, s->id, oldip, newip, updater);
3568
3569 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003570 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003571
3572 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003573 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003574 }
3575
3576 /* save the new IP family */
3577 s->addr.ss_family = ip_sin_family;
3578 /* save the new IP address */
3579 switch (ip_sin_family) {
3580 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02003581 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003582 break;
3583 case AF_INET6:
3584 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
3585 break;
3586 };
Olivier Houchard4e694042017-03-14 20:01:29 +01003587 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07003588 srv_set_addr_desc(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003589
3590 return 0;
3591}
3592
William Dauchy7cabc062021-02-11 22:51:24 +01003593/* update agent health check address and port
3594 * addr can be ip4/ip6 or a hostname
3595 * if one error occurs, don't apply anything
3596 * must be called with the server lock held.
3597 */
3598static const char *update_server_agent_addr_port(struct server *s, const char *addr,
3599 const char *port)
3600{
3601 struct sockaddr_storage sk;
3602 struct buffer *msg;
3603 int new_port;
3604
3605 msg = get_trash_chunk();
3606 chunk_reset(msg);
3607
3608 if (!(s->agent.state & CHK_ST_ENABLED)) {
3609 chunk_strcat(msg, "agent checks are not enabled on this server");
3610 goto out;
3611 }
3612 if (addr) {
3613 memset(&sk, 0, sizeof(struct sockaddr_storage));
3614 if (str2ip(addr, &sk) == NULL) {
3615 chunk_appendf(msg, "invalid addr '%s'", addr);
3616 goto out;
3617 }
3618 }
3619 if (port) {
3620 if (strl2irc(port, strlen(port), &new_port) != 0) {
3621 chunk_appendf(msg, "provided port is not an integer");
3622 goto out;
3623 }
3624 if (new_port < 0 || new_port > 65535) {
3625 chunk_appendf(msg, "provided port is invalid");
3626 goto out;
3627 }
3628 }
3629out:
3630 if (msg->data)
3631 return msg->area;
3632 else {
3633 if (addr)
3634 set_srv_agent_addr(s, &sk);
3635 if (port)
3636 set_srv_agent_port(s, new_port);
3637 }
3638 return NULL;
3639}
3640
William Dauchyb456e1f2021-02-11 22:51:23 +01003641/* update server health check address and port
3642 * addr must be ip4 or ip6, it won't be resolved
3643 * if one error occurs, don't apply anything
3644 * must be called with the server lock held.
3645 */
3646static const char *update_server_check_addr_port(struct server *s, const char *addr,
3647 const char *port)
3648{
3649 struct sockaddr_storage sk;
3650 struct buffer *msg;
3651 int new_port;
3652
3653 msg = get_trash_chunk();
3654 chunk_reset(msg);
3655
3656 if (!(s->check.state & CHK_ST_ENABLED)) {
3657 chunk_strcat(msg, "health checks are not enabled on this server");
3658 goto out;
3659 }
3660 if (addr) {
3661 memset(&sk, 0, sizeof(struct sockaddr_storage));
3662 if (str2ip2(addr, &sk, 0) == NULL) {
3663 chunk_appendf(msg, "invalid addr '%s'", addr);
3664 goto out;
3665 }
3666 }
3667 if (port) {
3668 if (strl2irc(port, strlen(port), &new_port) != 0) {
3669 chunk_appendf(msg, "provided port is not an integer");
3670 goto out;
3671 }
3672 if (new_port < 0 || new_port > 65535) {
3673 chunk_appendf(msg, "provided port is invalid");
3674 goto out;
3675 }
3676 /* prevent the update of port to 0 if MAPPORTS are in use */
3677 if ((s->flags & SRV_F_MAPPORTS) && new_port == 0) {
3678 chunk_appendf(msg, "can't unset 'port' since MAPPORTS is in use");
3679 goto out;
3680 }
3681 }
3682out:
3683 if (msg->data)
3684 return msg->area;
3685 else {
3686 if (addr)
3687 s->check.addr = sk;
3688 if (port)
3689 s->check.port = new_port;
3690 }
3691 return NULL;
3692}
3693
Baptiste Assmann14e40142015-04-14 01:13:07 +02003694/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003695 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3696 *
3697 * Caller can pass its name through <updater> to get it integrated in the response message
3698 * returned by the function.
3699 *
3700 * The function first does the following, in that order:
3701 * - validates the new addr and/or port
3702 * - checks if an update is required (new IP or port is different than current ones)
3703 * - checks the update is allowed:
3704 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3705 * - allow all changes if no CHECKS are configured
3706 * - if CHECK is configured:
3707 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3708 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3709 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02003710 *
3711 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003712 */
3713const char *update_server_addr_port(struct server *s, const char *addr, const char *port, char *updater)
3714{
3715 struct sockaddr_storage sa;
3716 int ret, port_change_required;
3717 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003718 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02003719 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003720 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003721
3722 msg = get_trash_chunk();
3723 chunk_reset(msg);
3724
3725 if (addr) {
3726 memset(&sa, 0, sizeof(struct sockaddr_storage));
3727 if (str2ip2(addr, &sa, 0) == NULL) {
3728 chunk_printf(msg, "Invalid addr '%s'", addr);
3729 goto out;
3730 }
3731
3732 /* changes are allowed on AF_INET* families only */
3733 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3734 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3735 goto out;
3736 }
3737
3738 /* collecting data currently setup */
3739 memset(current_addr, '\0', sizeof(current_addr));
3740 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3741 /* changes are allowed on AF_INET* families only */
3742 if ((ret != AF_INET) && (ret != AF_INET6)) {
3743 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3744 goto out;
3745 }
3746
3747 /* applying ADDR changes if required and allowed
3748 * ipcmp returns 0 when both ADDR are the same
3749 */
3750 if (ipcmp(&s->addr, &sa) == 0) {
3751 chunk_appendf(msg, "no need to change the addr");
3752 goto port;
3753 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003754 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003755 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003756
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003757 /* update report for caller */
3758 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3759 }
3760
3761 port:
3762 if (port) {
3763 char sign = '\0';
3764 char *endptr;
3765
3766 if (addr)
3767 chunk_appendf(msg, ", ");
3768
3769 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003770 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003771
3772 /* check if PORT change is required */
3773 port_change_required = 0;
3774
3775 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003776 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003777 new_port = strtol(port, &endptr, 10);
3778 if ((errno != 0) || (port == endptr)) {
3779 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3780 goto out;
3781 }
3782
3783 /* check if caller triggers a port mapped or offset */
3784 if (sign == '-' || (sign == '+')) {
3785 /* check if server currently uses port map */
3786 if (!(s->flags & SRV_F_MAPPORTS)) {
3787 /* switch from fixed port to port map mandatorily triggers
3788 * a port change */
3789 port_change_required = 1;
3790 /* check is configured
3791 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3792 * prevent PORT change if check doesn't have it's dedicated port while switching
3793 * to port mapping */
William Dauchy69f118d2021-02-03 22:30:07 +01003794 if (!s->check.port) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003795 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.");
3796 goto out;
3797 }
3798 }
3799 /* we're already using port maps */
3800 else {
3801 port_change_required = current_port != new_port;
3802 }
3803 }
3804 /* fixed port */
3805 else {
3806 port_change_required = current_port != new_port;
3807 }
3808
3809 /* applying PORT changes if required and update response message */
3810 if (port_change_required) {
3811 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003812 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003813 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003814
3815 /* prepare message */
3816 chunk_appendf(msg, "port changed from '");
3817 if (s->flags & SRV_F_MAPPORTS)
3818 chunk_appendf(msg, "+");
3819 chunk_appendf(msg, "%d' to '", current_port);
3820
3821 if (sign == '-') {
3822 s->flags |= SRV_F_MAPPORTS;
3823 chunk_appendf(msg, "%c", sign);
3824 /* just use for result output */
3825 new_port = -new_port;
3826 }
3827 else if (sign == '+') {
3828 s->flags |= SRV_F_MAPPORTS;
3829 chunk_appendf(msg, "%c", sign);
3830 }
3831 else {
3832 s->flags &= ~SRV_F_MAPPORTS;
3833 }
3834
3835 chunk_appendf(msg, "%d'", new_port);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003836 }
3837 else {
3838 chunk_appendf(msg, "no need to change the port");
3839 }
3840 }
3841
3842out:
William Dauchy6318d332020-05-02 21:52:36 +02003843 if (changed) {
3844 /* force connection cleanup on the given server */
3845 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01003846 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07003847 srv_set_addr_desc(s);
William Dauchy6318d332020-05-02 21:52:36 +02003848 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003849 if (updater)
3850 chunk_appendf(msg, " by '%s'", updater);
3851 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003852 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003853}
3854
3855
3856/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003857 * update server status based on result of name resolution
3858 * returns:
3859 * 0 if server status is updated
3860 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003861 *
3862 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003863 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003864int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003865{
Emeric Brun750fe792020-12-23 16:51:12 +01003866 struct resolvers *resolvers = s->resolvers;
Emeric Brun08622d32020-12-23 17:41:43 +01003867 struct resolv_resolution *resolution = s->resolv_requester->resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003868 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003869
Jerome Magnin012261a2020-07-28 13:38:22 +02003870 /* If resolution is NULL we're dealing with SRV records Additional records */
3871 if (resolution == NULL) {
Baptiste Assmann87138c32020-08-04 10:57:21 +02003872 /* since this server has an IP, it can go back in production */
3873 if (has_no_ip == 0) {
3874 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3875 return 1;
3876 }
3877
Jerome Magnin012261a2020-07-28 13:38:22 +02003878 if (s->next_admin & SRV_ADMF_RMAINT)
3879 return 1;
3880
3881 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
3882 return 0;
3883 }
3884
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003885 switch (resolution->status) {
3886 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003887 /* status when HAProxy has just (re)started.
3888 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003889 break;
3890
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003891 case RSLV_STATUS_VALID:
3892 /*
3893 * resume health checks
3894 * server will be turned back on if health check is safe
3895 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003896 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003897 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003898 return 1;
3899 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3900 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003901 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003902 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003903
Emeric Brun52a91d32017-08-31 14:41:55 +02003904 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003905 return 1;
3906 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3907 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3908 s->proxy->id, s->id);
3909
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003910 ha_warning("%s.\n", trash.area);
3911 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003912 return 0;
3913
3914 case RSLV_STATUS_NX:
3915 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003916 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3917 if (!tick_is_expired(exp, now_ms))
3918 break;
3919
3920 if (s->next_admin & SRV_ADMF_RMAINT)
3921 return 1;
3922 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3923 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003924
3925 case RSLV_STATUS_TIMEOUT:
3926 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003927 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3928 if (!tick_is_expired(exp, now_ms))
3929 break;
3930
3931 if (s->next_admin & SRV_ADMF_RMAINT)
3932 return 1;
3933 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3934 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003935
3936 case RSLV_STATUS_REFUSED:
3937 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003938 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3939 if (!tick_is_expired(exp, now_ms))
3940 break;
3941
3942 if (s->next_admin & SRV_ADMF_RMAINT)
3943 return 1;
3944 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3945 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003946
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003947 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003948 /* stop server if resolution failed for a long enough period */
3949 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3950 if (!tick_is_expired(exp, now_ms))
3951 break;
3952
3953 if (s->next_admin & SRV_ADMF_RMAINT)
3954 return 1;
3955 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3956 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003957 }
3958
3959 return 1;
3960}
3961
3962/*
3963 * Server Name Resolution valid response callback
3964 * It expects:
3965 * - <nameserver>: the name server which answered the valid response
3966 * - <response>: buffer containing a valid DNS response
3967 * - <response_len>: size of <response>
3968 * It performs the following actions:
3969 * - ignore response if current ip found and server family not met
3970 * - update with first new ip found if family is met and current IP is not found
3971 * returns:
3972 * 0 on error
3973 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003974 *
3975 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003976 */
Emeric Brun08622d32020-12-23 17:41:43 +01003977int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *counters)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003978{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003979 struct server *s = NULL;
Emeric Brun08622d32020-12-23 17:41:43 +01003980 struct resolv_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003981 void *serverip, *firstip;
3982 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003983 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003984 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003985 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003986
Christopher Faulet67957bd2017-09-27 11:00:59 +02003987 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003988 if (!s)
3989 return 1;
3990
Emeric Brun08622d32020-12-23 17:41:43 +01003991 resolution = s->resolv_requester->resolution;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003992
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003993 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003994 firstip = NULL; /* pointer to the first valid response found */
3995 /* it will be used as the new IP if a change is required */
3996 firstip_sin_family = AF_UNSPEC;
3997 serverip = NULL; /* current server IP address */
3998
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003999 /* initializing server IP pointer */
4000 server_sin_family = s->addr.ss_family;
4001 switch (server_sin_family) {
4002 case AF_INET:
4003 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
4004 break;
4005
4006 case AF_INET6:
4007 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
4008 break;
4009
Willy Tarreau3acfcd12017-01-06 19:18:32 +01004010 case AF_UNSPEC:
4011 break;
4012
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004013 default:
4014 goto invalid;
4015 }
4016
Emeric Brund30e9a12020-12-23 18:49:16 +01004017 ret = resolv_get_ip_from_response(&resolution->response, &s->resolv_opts,
4018 serverip, server_sin_family, &firstip,
4019 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004020
4021 switch (ret) {
Emeric Brun456de772020-12-23 18:17:31 +01004022 case RSLV_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004023 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004024
Emeric Brun456de772020-12-23 18:17:31 +01004025 case RSLV_UPD_SRVIP_NOT_FOUND:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004026 goto save_ip;
4027
Emeric Brun456de772020-12-23 18:17:31 +01004028 case RSLV_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004029 goto invalid;
4030
Emeric Brun456de772020-12-23 18:17:31 +01004031 case RSLV_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004032 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004033 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02004034
Emeric Brun456de772020-12-23 18:17:31 +01004035 case RSLV_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01004036 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02004037 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004038 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01004039
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004040 default:
4041 goto invalid;
4042
4043 }
4044
4045 save_ip:
Emeric Brun50c870e2021-01-04 10:40:46 +01004046 if (counters) {
4047 counters->update++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004048 /* save the first ip we found */
Emeric Brun50c870e2021-01-04 10:40:46 +01004049 chunk_printf(chk, "%s/%s", counters->pid, counters->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004050 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004051 else
4052 chunk_printf(chk, "DNS cache");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004053 update_server_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004054
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004055 update_status:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004056 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004057 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004058
4059 invalid:
Emeric Brun50c870e2021-01-04 10:40:46 +01004060 if (counters) {
4061 counters->invalid++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004062 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02004063 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004064 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004065 return 0;
4066}
4067
4068/*
4069 * Server Name Resolution error management callback
4070 * returns:
4071 * 0 on error
4072 * 1 when no error or safe ignore
Willy Tarreau46b7f532018-08-21 11:54:26 +02004073 *
4074 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004075 */
Emeric Brun08622d32020-12-23 17:41:43 +01004076int snr_resolution_error_cb(struct resolv_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004077{
Christopher Faulet67957bd2017-09-27 11:00:59 +02004078 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004079
Christopher Faulet67957bd2017-09-27 11:00:59 +02004080 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004081 if (!s)
4082 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004083 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004084 snr_update_srv_status(s, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004085 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004086 return 1;
4087}
4088
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004089/*
4090 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004091 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004092 * It returns a pointer to the first server found or NULL if <ip> is not yet
4093 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01004094 *
4095 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004096 */
4097struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
4098{
4099 struct server *tmpsrv;
4100 struct proxy *be;
4101
4102 if (!srv)
4103 return NULL;
4104
4105 be = srv->proxy;
4106 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01004107 /* we found the current server is the same, ignore it */
4108 if (srv == tmpsrv)
4109 continue;
4110
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004111 /* We want to compare the IP in the record with the IP of the servers in the
4112 * same backend, only if:
4113 * * DNS resolution is enabled on the server
4114 * * the hostname used for the resolution by our server is the same than the
4115 * one used for the server found in the backend
4116 * * the server found in the backend is not our current server
4117 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004118 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004119 if ((tmpsrv->hostname_dn == NULL) ||
4120 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
4121 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01004122 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004123 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004124 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01004125 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004126
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004127 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01004128 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004129 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004130 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01004131 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004132
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004133 /* At this point, we have 2 different servers using the same DNS hostname
4134 * for their respective resolution.
4135 */
4136 if (*ip_family == tmpsrv->addr.ss_family &&
4137 ((tmpsrv->addr.ss_family == AF_INET &&
4138 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
4139 (tmpsrv->addr.ss_family == AF_INET6 &&
4140 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004141 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004142 return tmpsrv;
4143 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004144 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004145 }
4146
Emeric Brune9fd6b52017-11-02 17:20:39 +01004147
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004148 return NULL;
4149}
4150
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004151/* Sets the server's address (srv->addr) from srv->hostname using the libc's
4152 * resolver. This is suited for initial address configuration. Returns 0 on
4153 * success otherwise a non-zero error code. In case of error, *err_code, if
4154 * not NULL, is filled up.
4155 */
4156int srv_set_addr_via_libc(struct server *srv, int *err_code)
4157{
4158 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004159 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01004160 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004161 return 1;
4162 }
4163 return 0;
4164}
4165
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004166/* Set the server's FDQN (->hostname) from <hostname>.
4167 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004168 *
4169 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004170 */
Emeric Brun08622d32020-12-23 17:41:43 +01004171int srv_set_fqdn(struct server *srv, const char *hostname, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004172{
Emeric Brun08622d32020-12-23 17:41:43 +01004173 struct resolv_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004174 char *hostname_dn;
4175 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004176
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02004177 /* Note that the server lock is already held. */
4178 if (!srv->resolvers)
4179 return -1;
4180
Emeric Brun08622d32020-12-23 17:41:43 +01004181 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004182 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004183 /* run time DNS resolution was not active for this server
4184 * and we can't enable it at run time for now.
4185 */
Emeric Brun08622d32020-12-23 17:41:43 +01004186 if (!srv->resolv_requester)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004187 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004188
4189 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004190 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004191 hostname_dn = trash.area;
Emeric Brund30e9a12020-12-23 18:49:16 +01004192 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len + 1,
4193 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004194 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004195 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004196
Emeric Brun08622d32020-12-23 17:41:43 +01004197 resolution = srv->resolv_requester->resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004198 if (resolution &&
4199 resolution->hostname_dn &&
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004200 strcmp(resolution->hostname_dn, hostname_dn) == 0)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004201 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004202
Emeric Brund30e9a12020-12-23 18:49:16 +01004203 resolv_unlink_resolution(srv->resolv_requester);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004204
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004205 free(srv->hostname);
4206 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004207 srv->hostname = strdup(hostname);
4208 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004209 srv->hostname_dn_len = hostname_dn_len;
4210 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004211 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004212
Baptiste Assmann13a92322019-06-07 09:40:55 +02004213 if (srv->flags & SRV_F_NO_RESOLUTION)
4214 goto end;
4215
Emeric Brund30e9a12020-12-23 18:49:16 +01004216 if (resolv_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004217 goto err;
4218
4219 end:
Emeric Brun08622d32020-12-23 17:41:43 +01004220 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004221 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004222 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02004223
4224 err:
Emeric Brun08622d32020-12-23 17:41:43 +01004225 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004226 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02004227 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004228}
4229
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004230/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
4231 * from the state file. This is suited for initial address configuration.
4232 * Returns 0 on success otherwise a non-zero error code. In case of error,
4233 * *err_code, if not NULL, is filled up.
4234 */
4235static int srv_apply_lastaddr(struct server *srv, int *err_code)
4236{
4237 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
4238 if (err_code)
4239 *err_code |= ERR_WARN;
4240 return 1;
4241 }
4242 return 0;
4243}
4244
Willy Tarreau25e51522016-11-04 15:10:17 +01004245/* returns 0 if no error, otherwise a combination of ERR_* flags */
4246static int srv_iterate_initaddr(struct server *srv)
4247{
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004248 char *name = srv->hostname;
Willy Tarreau25e51522016-11-04 15:10:17 +01004249 int return_code = 0;
4250 int err_code;
4251 unsigned int methods;
4252
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004253 /* If no addr and no hostname set, get the name from the DNS SRV request */
4254 if (!name && srv->srvrq)
4255 name = srv->srvrq->name;
4256
Willy Tarreau25e51522016-11-04 15:10:17 +01004257 methods = srv->init_addr_methods;
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004258 if (!methods) {
4259 /* otherwise default to "last,libc" */
Willy Tarreau25e51522016-11-04 15:10:17 +01004260 srv_append_initaddr(&methods, SRV_IADDR_LAST);
4261 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004262 if (srv->resolvers_id) {
4263 /* dns resolution is configured, add "none" to not fail on startup */
4264 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4265 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004266 }
4267
Willy Tarreau3eed10e2016-11-07 21:03:16 +01004268 /* "-dr" : always append "none" so that server addresses resolution
4269 * failures are silently ignored, this is convenient to validate some
4270 * configs out of their environment.
4271 */
4272 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
4273 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4274
Willy Tarreau25e51522016-11-04 15:10:17 +01004275 while (methods) {
4276 err_code = 0;
4277 switch (srv_get_next_initaddr(&methods)) {
4278 case SRV_IADDR_LAST:
4279 if (!srv->lastaddr)
4280 continue;
4281 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004282 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004283 return_code |= err_code;
4284 break;
4285
4286 case SRV_IADDR_LIBC:
4287 if (!srv->hostname)
4288 continue;
4289 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004290 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004291 return_code |= err_code;
4292 break;
4293
Willy Tarreau37ebe122016-11-04 15:17:58 +01004294 case SRV_IADDR_NONE:
4295 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004296 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004297 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004298 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004299 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01004300 return return_code;
4301
Willy Tarreau4310d362016-11-02 15:05:56 +01004302 case SRV_IADDR_IP:
4303 ipcpy(&srv->init_addr, &srv->addr);
4304 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004305 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 +01004306 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau4310d362016-11-02 15:05:56 +01004307 }
Olivier Houchard4e694042017-03-14 20:01:29 +01004308 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01004309
Willy Tarreau25e51522016-11-04 15:10:17 +01004310 default: /* unhandled method */
4311 break;
4312 }
4313 }
4314
4315 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004316 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004317 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau25e51522016-11-04 15:10:17 +01004318 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01004319 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004320 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004321 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004322 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004323
4324 return_code |= ERR_ALERT | ERR_FATAL;
4325 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01004326out:
4327 srv_set_dyncookie(srv);
Thayne McCombs92149f92020-11-20 01:28:26 -07004328 srv_set_addr_desc(srv);
Olivier Houchard4e694042017-03-14 20:01:29 +01004329 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01004330}
4331
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004332/*
4333 * This function parses all backends and all servers within each backend
4334 * and performs servers' addr resolution based on information provided by:
4335 * - configuration file
4336 * - server-state file (states provided by an 'old' haproxy process)
4337 *
4338 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
4339 */
4340int srv_init_addr(void)
4341{
4342 struct proxy *curproxy;
4343 int return_code = 0;
4344
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004345 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004346 while (curproxy) {
4347 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004348
4349 /* servers are in backend only */
Amaury Denoyellee3c41922021-01-06 14:28:50 +01004350 if (!(curproxy->cap & PR_CAP_BE) || curproxy->disabled)
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004351 goto srv_init_addr_next;
4352
Willy Tarreau25e51522016-11-04 15:10:17 +01004353 for (srv = curproxy->srv; srv; srv = srv->next)
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004354 if (srv->hostname || srv->srvrq)
Willy Tarreau3d609a72017-09-06 14:22:45 +02004355 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004356
4357 srv_init_addr_next:
4358 curproxy = curproxy->next;
4359 }
4360
4361 return return_code;
4362}
4363
Willy Tarreau46b7f532018-08-21 11:54:26 +02004364/*
4365 * Must be called with the server lock held.
4366 */
Emeric Brun08622d32020-12-23 17:41:43 +01004367const char *update_server_fqdn(struct server *server, const char *fqdn, const char *updater, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004368{
4369
Willy Tarreau83061a82018-07-13 11:56:34 +02004370 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004371
4372 msg = get_trash_chunk();
4373 chunk_reset(msg);
4374
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004375 if (server->hostname && strcmp(fqdn, server->hostname) == 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004376 chunk_appendf(msg, "no need to change the FDQN");
4377 goto out;
4378 }
4379
4380 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
4381 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
4382 goto out;
4383 }
4384
4385 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
4386 server->proxy->id, server->id, server->hostname, fqdn);
4387
Emeric Brun08622d32020-12-23 17:41:43 +01004388 if (srv_set_fqdn(server, fqdn, resolv_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004389 chunk_reset(msg);
4390 chunk_appendf(msg, "could not update %s/%s FQDN",
4391 server->proxy->id, server->id);
4392 goto out;
4393 }
4394
4395 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02004396 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004397
4398 out:
4399 if (updater)
4400 chunk_appendf(msg, " by '%s'", updater);
4401 chunk_appendf(msg, "\n");
4402
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004403 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004404}
4405
4406
Willy Tarreau21b069d2016-11-23 17:15:08 +01004407/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
4408 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004409 * 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 +01004410 * used for CLI commands requiring a server name.
4411 * Important: the <arg> is modified to remove the '/'.
4412 */
4413struct server *cli_find_server(struct appctx *appctx, char *arg)
4414{
4415 struct proxy *px;
4416 struct server *sv;
4417 char *line;
4418
4419 /* split "backend/server" and make <line> point to server */
4420 for (line = arg; *line; line++)
4421 if (*line == '/') {
4422 *line++ = '\0';
4423 break;
4424 }
4425
4426 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004427 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004428 return NULL;
4429 }
4430
4431 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004432 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004433 return NULL;
4434 }
4435
Willy Tarreauc3914d42020-09-24 08:39:22 +02004436 if (px->disabled) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004437 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004438 return NULL;
4439 }
4440
4441 return sv;
4442}
4443
William Lallemand222baf22016-11-19 02:00:33 +01004444
Willy Tarreau46b7f532018-08-21 11:54:26 +02004445/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004446static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01004447{
4448 struct server *sv;
4449 const char *warning;
4450
4451 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4452 return 1;
4453
4454 sv = cli_find_server(appctx, args[2]);
4455 if (!sv)
4456 return 1;
4457
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004458 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02004459
William Lallemand222baf22016-11-19 02:00:33 +01004460 if (strcmp(args[3], "weight") == 0) {
4461 warning = server_parse_weight_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004462 if (warning)
4463 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004464 }
4465 else if (strcmp(args[3], "state") == 0) {
4466 if (strcmp(args[4], "ready") == 0)
4467 srv_adm_set_ready(sv);
4468 else if (strcmp(args[4], "drain") == 0)
4469 srv_adm_set_drain(sv);
4470 else if (strcmp(args[4], "maint") == 0)
4471 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02004472 else
4473 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004474 }
4475 else if (strcmp(args[3], "health") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004476 if (sv->track)
4477 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004478 else if (strcmp(args[4], "up") == 0) {
4479 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004480 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004481 }
4482 else if (strcmp(args[4], "stopping") == 0) {
4483 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004484 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004485 }
4486 else if (strcmp(args[4], "down") == 0) {
4487 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004488 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004489 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004490 else
4491 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004492 }
4493 else if (strcmp(args[3], "agent") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004494 if (!(sv->agent.state & CHK_ST_ENABLED))
4495 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004496 else if (strcmp(args[4], "up") == 0) {
4497 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004498 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004499 }
4500 else if (strcmp(args[4], "down") == 0) {
4501 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004502 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004503 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004504 else
4505 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004506 }
Misiek2da082d2017-01-09 09:40:42 +01004507 else if (strcmp(args[3], "agent-addr") == 0) {
William Dauchy7cabc062021-02-11 22:51:24 +01004508 char *addr = NULL;
4509 char *port = NULL;
4510 if (strlen(args[4]) == 0) {
4511 cli_err(appctx, "set server <b>/<s> agent-addr requires"
4512 " an address and optionally a port.\n");
4513 goto out_unlock;
4514 }
4515 addr = args[4];
4516 if (strcmp(args[5], "port") == 0)
4517 port = args[6];
4518 warning = update_server_agent_addr_port(sv, addr, port);
4519 if (warning)
4520 cli_msg(appctx, LOG_WARNING, warning);
4521 }
4522 else if (strcmp(args[3], "agent-port") == 0) {
4523 char *port = NULL;
4524 if (strlen(args[4]) == 0) {
4525 cli_err(appctx, "set server <b>/<s> agent-port requires"
4526 " a port.\n");
4527 goto out_unlock;
4528 }
4529 port = args[4];
4530 warning = update_server_agent_addr_port(sv, NULL, port);
4531 if (warning)
4532 cli_msg(appctx, LOG_WARNING, warning);
Misiek2da082d2017-01-09 09:40:42 +01004533 }
4534 else if (strcmp(args[3], "agent-send") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004535 if (!(sv->agent.state & CHK_ST_ENABLED))
4536 cli_err(appctx, "agent checks are not enabled on this server.\n");
4537 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02004538 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02004539 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01004540 }
4541 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004542 else if (strcmp(args[3], "check-addr") == 0) {
4543 char *addr = NULL;
4544 char *port = NULL;
4545 if (strlen(args[4]) == 0) {
4546 cli_err(appctx, "set server <b>/<s> check-addr requires"
4547 " an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004548 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004549 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004550 addr = args[4];
4551 if (strcmp(args[5], "port") == 0)
4552 port = args[6];
4553 warning = update_server_check_addr_port(sv, addr, port);
4554 if (warning)
4555 cli_msg(appctx, LOG_WARNING, warning);
4556 }
4557 else if (strcmp(args[3], "check-port") == 0) {
4558 char *port = NULL;
4559 if (strlen(args[4]) == 0) {
4560 cli_err(appctx, "set server <b>/<s> check-port requires"
4561 " a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004562 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004563 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004564 port = args[4];
4565 warning = update_server_check_addr_port(sv, NULL, port);
4566 if (warning)
4567 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004568 }
4569 else if (strcmp(args[3], "addr") == 0) {
4570 char *addr = NULL;
4571 char *port = NULL;
4572 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004573 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004574 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004575 }
4576 else {
4577 addr = args[4];
4578 }
4579 if (strcmp(args[5], "port") == 0) {
4580 port = args[6];
4581 }
4582 warning = update_server_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02004583 if (warning)
4584 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004585 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
4586 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004587 else if (strcmp(args[3], "fqdn") == 0) {
4588 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004589 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004590 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004591 }
Baptiste Assmann13a92322019-06-07 09:40:55 +02004592 /* ensure runtime resolver will process this new fqdn */
4593 if (sv->flags & SRV_F_NO_RESOLUTION) {
4594 sv->flags &= ~SRV_F_NO_RESOLUTION;
4595 }
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004596 warning = update_server_fqdn(sv, args[4], "stats socket command", 0);
Willy Tarreau9d008692019-08-09 11:21:01 +02004597 if (warning)
4598 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004599 }
William Dauchyf6370442020-11-14 19:25:33 +01004600 else if (strcmp(args[3], "ssl") == 0) {
4601#ifdef USE_OPENSSL
4602 if (sv->ssl_ctx.ctx == NULL) {
4603 cli_err(appctx, "'set server <srv> ssl' cannot be set. "
4604 " default-server should define ssl settings\n");
4605 goto out_unlock;
4606 } else if (strcmp(args[4], "on") == 0) {
4607 ssl_sock_set_srv(sv, 1);
4608 } else if (strcmp(args[4], "off") == 0) {
4609 ssl_sock_set_srv(sv, 0);
4610 } else {
4611 cli_err(appctx, "'set server <srv> ssl' expects 'on' or 'off'.\n");
4612 goto out_unlock;
4613 }
4614 srv_cleanup_connections(sv);
4615 cli_msg(appctx, LOG_NOTICE, "server ssl setting updated.\n");
4616#else
4617 cli_msg(appctx, LOG_NOTICE, "server ssl setting not supported.\n");
4618#endif
4619 } else {
Willy Tarreau9d008692019-08-09 11:21:01 +02004620 cli_err(appctx,
William Dauchyb456e1f2021-02-11 22:51:23 +01004621 "'set server <srv>' only supports 'agent', 'health', "
4622 "'state', 'weight', 'addr', 'fqdn', 'check-addr', "
4623 "'check-port' and 'ssl'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004624 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004625 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004626 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004627 return 1;
4628}
4629
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004630static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004631{
4632 struct stream_interface *si = appctx->owner;
4633 struct proxy *px;
4634 struct server *sv;
4635 char *line;
4636
4637
4638 /* split "backend/server" and make <line> point to server */
4639 for (line = args[2]; *line; line++)
4640 if (*line == '/') {
4641 *line++ = '\0';
4642 break;
4643 }
4644
Willy Tarreau9d008692019-08-09 11:21:01 +02004645 if (!*line)
4646 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004647
Willy Tarreau9d008692019-08-09 11:21:01 +02004648 if (!get_backend_server(args[2], line, &px, &sv))
4649 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004650
4651 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004652 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
4653 sv->iweight);
4654 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004655 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004656 return 0;
4657 }
William Lallemand6b160942016-11-22 12:34:35 +01004658 return 1;
4659}
4660
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004661/* Parse a "set weight" command.
4662 *
4663 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004664 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004665static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004666{
4667 struct server *sv;
4668 const char *warning;
4669
4670 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4671 return 1;
4672
4673 sv = cli_find_server(appctx, args[2]);
4674 if (!sv)
4675 return 1;
4676
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004677 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4678
William Lallemand6b160942016-11-22 12:34:35 +01004679 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004680 if (warning)
4681 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004682
4683 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4684
William Lallemand6b160942016-11-22 12:34:35 +01004685 return 1;
4686}
4687
Willy Tarreau46b7f532018-08-21 11:54:26 +02004688/* parse a "set maxconn server" command. It always returns 1.
4689 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004690 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004691 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004692static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01004693{
4694 struct server *sv;
4695 const char *warning;
4696
4697 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4698 return 1;
4699
4700 sv = cli_find_server(appctx, args[3]);
4701 if (!sv)
4702 return 1;
4703
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004704 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4705
Willy Tarreaub8026272016-11-23 11:26:56 +01004706 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004707 if (warning)
4708 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004709
4710 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4711
Willy Tarreaub8026272016-11-23 11:26:56 +01004712 return 1;
4713}
William Lallemand6b160942016-11-22 12:34:35 +01004714
Willy Tarreau46b7f532018-08-21 11:54:26 +02004715/* parse a "disable agent" command. It always returns 1.
4716 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004717 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004718 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004719static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004720{
4721 struct server *sv;
4722
4723 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4724 return 1;
4725
4726 sv = cli_find_server(appctx, args[2]);
4727 if (!sv)
4728 return 1;
4729
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004730 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004731 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004732 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004733 return 1;
4734}
4735
Willy Tarreau46b7f532018-08-21 11:54:26 +02004736/* parse a "disable health" command. It always returns 1.
4737 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004738 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004739 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004740static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004741{
4742 struct server *sv;
4743
4744 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4745 return 1;
4746
4747 sv = cli_find_server(appctx, args[2]);
4748 if (!sv)
4749 return 1;
4750
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004751 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004752 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004753 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004754 return 1;
4755}
4756
Willy Tarreau46b7f532018-08-21 11:54:26 +02004757/* parse a "disable server" command. It always returns 1.
4758 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004759 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004760 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004761static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004762{
4763 struct server *sv;
4764
4765 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4766 return 1;
4767
4768 sv = cli_find_server(appctx, args[2]);
4769 if (!sv)
4770 return 1;
4771
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004772 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004773 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004774 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004775 return 1;
4776}
4777
Willy Tarreau46b7f532018-08-21 11:54:26 +02004778/* parse a "enable agent" command. It always returns 1.
4779 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004780 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004781 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004782static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004783{
4784 struct server *sv;
4785
4786 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4787 return 1;
4788
4789 sv = cli_find_server(appctx, args[2]);
4790 if (!sv)
4791 return 1;
4792
Willy Tarreau9d008692019-08-09 11:21:01 +02004793 if (!(sv->agent.state & CHK_ST_CONFIGURED))
4794 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004795
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004796 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004797 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004798 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004799 return 1;
4800}
4801
Willy Tarreau46b7f532018-08-21 11:54:26 +02004802/* parse a "enable health" command. It always returns 1.
4803 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004804 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004805 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004806static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004807{
4808 struct server *sv;
4809
4810 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4811 return 1;
4812
4813 sv = cli_find_server(appctx, args[2]);
4814 if (!sv)
4815 return 1;
4816
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004817 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004818 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004819 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004820 return 1;
4821}
4822
Willy Tarreau46b7f532018-08-21 11:54:26 +02004823/* parse a "enable server" command. It always returns 1.
4824 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004825 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004826 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004827static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004828{
4829 struct server *sv;
4830
4831 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4832 return 1;
4833
4834 sv = cli_find_server(appctx, args[2]);
4835 if (!sv)
4836 return 1;
4837
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004838 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004839 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004840 if (!(sv->flags & SRV_F_COOKIESET)
4841 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4842 sv->cookie)
4843 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004844 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004845 return 1;
4846}
4847
William Lallemand222baf22016-11-19 02:00:33 +01004848/* register cli keywords */
4849static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004850 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004851 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004852 { { "disable", "server", NULL }, "disable server : disable a server for maintenance (use 'set server' instead)", cli_parse_disable_server, NULL },
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004853 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004854 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004855 { { "enable", "server", NULL }, "enable server : enable a disabled server (use 'set server' instead)", cli_parse_enable_server, NULL },
Willy Tarreaub8026272016-11-23 11:26:56 +01004856 { { "set", "maxconn", "server", NULL }, "set maxconn server : change a server's maxconn setting", cli_parse_set_maxconn_server, NULL },
William Dauchyf6370442020-11-14 19:25:33 +01004857 { { "set", "server", NULL }, "set server : change a server's state, weight, address or ssl", cli_parse_set_server },
William Lallemand6b160942016-11-22 12:34:35 +01004858 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4859 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4860
William Lallemand222baf22016-11-19 02:00:33 +01004861 {{},}
4862}};
4863
Willy Tarreau0108d902018-11-25 19:14:37 +01004864INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004865
Emeric Brun64cc49c2017-10-03 14:46:45 +02004866/*
4867 * This function applies server's status changes, it is
4868 * is designed to be called asynchronously.
4869 *
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004870 * Must be called with the server lock held. This may also be called at init
4871 * time as the result of parsing the state file, in which case no lock will be
4872 * held, and the server's warmup task can be null.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004873 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004874static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004875{
4876 struct check *check = &s->check;
4877 int xferred;
4878 struct proxy *px = s->proxy;
4879 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4880 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4881 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004882 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004883
Emeric Brun64cc49c2017-10-03 14:46:45 +02004884 /* If currently main is not set we try to apply pending state changes */
4885 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4886 int next_admin;
4887
4888 /* Backup next admin */
4889 next_admin = s->next_admin;
4890
4891 /* restore current admin state */
4892 s->next_admin = s->cur_admin;
4893
4894 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4895 s->last_change = now.tv_sec;
4896 if (s->proxy->lbprm.set_server_status_down)
4897 s->proxy->lbprm.set_server_status_down(s);
4898
4899 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4900 srv_shutdown_streams(s, SF_ERR_DOWN);
4901
4902 /* we might have streams queued on this server and waiting for
4903 * a connection. Those which are redispatchable will be queued
4904 * to another server or to the proxy itself.
4905 */
4906 xferred = pendconn_redistribute(s);
4907
4908 tmptrash = alloc_trash_chunk();
4909 if (tmptrash) {
4910 chunk_printf(tmptrash,
4911 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4912 s->proxy->id, s->id);
4913
Emeric Brun5a133512017-10-19 14:42:30 +02004914 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004915 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004916
4917 /* we don't send an alert if the server was previously paused */
4918 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004919 send_log(s->proxy, log_level, "%s.\n",
4920 tmptrash->area);
4921 send_email_alert(s, log_level, "%s",
4922 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004923 free_trash_chunk(tmptrash);
4924 tmptrash = NULL;
4925 }
4926 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4927 set_backend_down(s->proxy);
4928
4929 s->counters.down_trans++;
4930 }
4931 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4932 s->last_change = now.tv_sec;
4933 if (s->proxy->lbprm.set_server_status_down)
4934 s->proxy->lbprm.set_server_status_down(s);
4935
4936 /* we might have streams queued on this server and waiting for
4937 * a connection. Those which are redispatchable will be queued
4938 * to another server or to the proxy itself.
4939 */
4940 xferred = pendconn_redistribute(s);
4941
4942 tmptrash = alloc_trash_chunk();
4943 if (tmptrash) {
4944 chunk_printf(tmptrash,
4945 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4946 s->proxy->id, s->id);
4947
Emeric Brun5a133512017-10-19 14:42:30 +02004948 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004949
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004950 ha_warning("%s.\n", tmptrash->area);
4951 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4952 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004953 free_trash_chunk(tmptrash);
4954 tmptrash = NULL;
4955 }
4956
4957 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4958 set_backend_down(s->proxy);
4959 }
4960 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4961 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4962 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4963 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4964 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4965 s->proxy->last_change = now.tv_sec;
4966 }
4967
Amaury Denoyellefe2bf092020-10-29 15:59:04 +01004968 if (s->cur_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
Emeric Brun64cc49c2017-10-03 14:46:45 +02004969 s->down_time += now.tv_sec - s->last_change;
4970
4971 s->last_change = now.tv_sec;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004972 if (s->next_state == SRV_ST_STARTING && s->warmup)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004973 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4974
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004975 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004976 /* now propagate the status change to any LB algorithms */
4977 if (px->lbprm.update_server_eweight)
4978 px->lbprm.update_server_eweight(s);
4979 else if (srv_willbe_usable(s)) {
4980 if (px->lbprm.set_server_status_up)
4981 px->lbprm.set_server_status_up(s);
4982 }
4983 else {
4984 if (px->lbprm.set_server_status_down)
4985 px->lbprm.set_server_status_down(s);
4986 }
4987
4988 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4989 * and it's not a backup server and its effective weight is > 0,
4990 * then it can accept new connections, so we shut down all streams
4991 * on all backup servers.
4992 */
4993 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4994 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4995 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4996
4997 /* check if we can handle some connections queued at the proxy. We
4998 * will take as many as we can handle.
4999 */
5000 xferred = pendconn_grab_from_px(s);
5001
5002 tmptrash = alloc_trash_chunk();
5003 if (tmptrash) {
5004 chunk_printf(tmptrash,
5005 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
5006 s->proxy->id, s->id);
5007
Emeric Brun5a133512017-10-19 14:42:30 +02005008 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005009 ha_warning("%s.\n", tmptrash->area);
5010 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5011 tmptrash->area);
5012 send_email_alert(s, LOG_NOTICE, "%s",
5013 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005014 free_trash_chunk(tmptrash);
5015 tmptrash = NULL;
5016 }
5017
5018 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5019 set_backend_down(s->proxy);
5020 }
5021 else if (s->cur_eweight != s->next_eweight) {
5022 /* now propagate the status change to any LB algorithms */
5023 if (px->lbprm.update_server_eweight)
5024 px->lbprm.update_server_eweight(s);
5025 else if (srv_willbe_usable(s)) {
5026 if (px->lbprm.set_server_status_up)
5027 px->lbprm.set_server_status_up(s);
5028 }
5029 else {
5030 if (px->lbprm.set_server_status_down)
5031 px->lbprm.set_server_status_down(s);
5032 }
5033
5034 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5035 set_backend_down(s->proxy);
5036 }
5037
5038 s->next_admin = next_admin;
5039 }
5040
Emeric Brun5a133512017-10-19 14:42:30 +02005041 /* reset operational state change */
5042 *s->op_st_chg.reason = 0;
5043 s->op_st_chg.status = s->op_st_chg.code = -1;
5044 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005045
5046 /* Now we try to apply pending admin changes */
5047
5048 /* Maintenance must also disable health checks */
5049 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
5050 if (s->check.state & CHK_ST_ENABLED) {
5051 s->check.state |= CHK_ST_PAUSED;
5052 check->health = 0;
5053 }
5054
5055 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02005056 tmptrash = alloc_trash_chunk();
5057 if (tmptrash) {
5058 chunk_printf(tmptrash,
5059 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
5060 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5061 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02005062
Olivier Houchard796a2b32017-10-24 17:42:47 +02005063 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02005064
Olivier Houchard796a2b32017-10-24 17:42:47 +02005065 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005066 ha_warning("%s.\n", tmptrash->area);
5067 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5068 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02005069 }
5070 free_trash_chunk(tmptrash);
5071 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005072 }
Emeric Brun8f298292017-12-06 16:47:17 +01005073 /* commit new admin status */
5074
5075 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005076 }
5077 else { /* server was still running */
5078 check->health = 0; /* failure */
5079 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01005080
5081 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005082 if (s->proxy->lbprm.set_server_status_down)
5083 s->proxy->lbprm.set_server_status_down(s);
5084
Emeric Brun64cc49c2017-10-03 14:46:45 +02005085 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
5086 srv_shutdown_streams(s, SF_ERR_DOWN);
5087
William Dauchy6318d332020-05-02 21:52:36 +02005088 /* force connection cleanup on the given server */
5089 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005090 /* we might have streams queued on this server and waiting for
5091 * a connection. Those which are redispatchable will be queued
5092 * to another server or to the proxy itself.
5093 */
5094 xferred = pendconn_redistribute(s);
5095
5096 tmptrash = alloc_trash_chunk();
5097 if (tmptrash) {
5098 chunk_printf(tmptrash,
5099 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
5100 s->flags & SRV_F_BACKUP ? "Backup " : "",
5101 s->proxy->id, s->id,
5102 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5103
5104 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
5105
5106 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005107 ha_warning("%s.\n", tmptrash->area);
5108 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
5109 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005110 }
5111 free_trash_chunk(tmptrash);
5112 tmptrash = NULL;
5113 }
5114 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5115 set_backend_down(s->proxy);
5116
5117 s->counters.down_trans++;
5118 }
5119 }
5120 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
5121 /* OK here we're leaving maintenance, we have many things to check,
5122 * because the server might possibly be coming back up depending on
5123 * its state. In practice, leaving maintenance means that we should
5124 * immediately turn to UP (more or less the slowstart) under the
5125 * following conditions :
5126 * - server is neither checked nor tracked
5127 * - server tracks another server which is not checked
5128 * - server tracks another server which is already up
5129 * Which sums up as something simpler :
5130 * "either the tracking server is up or the server's checks are disabled
5131 * or up". Otherwise we only re-enable health checks. There's a special
5132 * case associated to the stopping state which can be inherited. Note
5133 * that the server might still be in drain mode, which is naturally dealt
5134 * with by the lower level functions.
5135 */
5136
5137 if (s->check.state & CHK_ST_ENABLED) {
5138 s->check.state &= ~CHK_ST_PAUSED;
5139 check->health = check->rise; /* start OK but check immediately */
5140 }
5141
5142 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
5143 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
5144 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
5145 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
5146 s->next_state = SRV_ST_STOPPING;
5147 }
5148 else {
5149 s->next_state = SRV_ST_STARTING;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02005150 if (s->slowstart > 0) {
5151 if (s->warmup)
5152 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
5153 }
Emeric Brun64cc49c2017-10-03 14:46:45 +02005154 else
5155 s->next_state = SRV_ST_RUNNING;
5156 }
5157
5158 }
5159
5160 tmptrash = alloc_trash_chunk();
5161 if (tmptrash) {
5162 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5163 chunk_printf(tmptrash,
5164 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
5165 s->flags & SRV_F_BACKUP ? "Backup " : "",
5166 s->proxy->id, s->id,
5167 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5168 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5169 }
5170 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5171 chunk_printf(tmptrash,
5172 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
5173 s->flags & SRV_F_BACKUP ? "Backup " : "",
5174 s->proxy->id, s->id, s->hostname,
5175 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5176 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5177 }
5178 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5179 chunk_printf(tmptrash,
5180 "%sServer %s/%s is %s/%s (leaving maintenance)",
5181 s->flags & SRV_F_BACKUP ? "Backup " : "",
5182 s->proxy->id, s->id,
5183 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5184 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5185 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005186 ha_warning("%s.\n", tmptrash->area);
5187 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5188 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005189 free_trash_chunk(tmptrash);
5190 tmptrash = NULL;
5191 }
5192
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005193 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005194 /* now propagate the status change to any LB algorithms */
5195 if (px->lbprm.update_server_eweight)
5196 px->lbprm.update_server_eweight(s);
5197 else if (srv_willbe_usable(s)) {
5198 if (px->lbprm.set_server_status_up)
5199 px->lbprm.set_server_status_up(s);
5200 }
5201 else {
5202 if (px->lbprm.set_server_status_down)
5203 px->lbprm.set_server_status_down(s);
5204 }
5205
5206 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5207 set_backend_down(s->proxy);
5208
Willy Tarreau6a78e612018-08-07 10:14:53 +02005209 /* If the server is set with "on-marked-up shutdown-backup-sessions",
5210 * and it's not a backup server and its effective weight is > 0,
5211 * then it can accept new connections, so we shut down all streams
5212 * on all backup servers.
5213 */
5214 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
5215 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
5216 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
5217
5218 /* check if we can handle some connections queued at the proxy. We
5219 * will take as many as we can handle.
5220 */
5221 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005222 }
5223 else if (s->next_admin & SRV_ADMF_MAINT) {
5224 /* remaining in maintenance mode, let's inform precisely about the
5225 * situation.
5226 */
5227 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5228 tmptrash = alloc_trash_chunk();
5229 if (tmptrash) {
5230 chunk_printf(tmptrash,
5231 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
5232 s->flags & SRV_F_BACKUP ? "Backup " : "",
5233 s->proxy->id, s->id);
5234
5235 if (s->track) /* normally it's mandatory here */
5236 chunk_appendf(tmptrash, " via %s/%s",
5237 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005238 ha_warning("%s.\n", tmptrash->area);
5239 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5240 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005241 free_trash_chunk(tmptrash);
5242 tmptrash = NULL;
5243 }
5244 }
5245 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5246 tmptrash = alloc_trash_chunk();
5247 if (tmptrash) {
5248 chunk_printf(tmptrash,
5249 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
5250 s->flags & SRV_F_BACKUP ? "Backup " : "",
5251 s->proxy->id, s->id, s->hostname);
5252
5253 if (s->track) /* normally it's mandatory here */
5254 chunk_appendf(tmptrash, " via %s/%s",
5255 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005256 ha_warning("%s.\n", tmptrash->area);
5257 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5258 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005259 free_trash_chunk(tmptrash);
5260 tmptrash = NULL;
5261 }
5262 }
5263 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5264 tmptrash = alloc_trash_chunk();
5265 if (tmptrash) {
5266 chunk_printf(tmptrash,
5267 "%sServer %s/%s remains in forced maintenance",
5268 s->flags & SRV_F_BACKUP ? "Backup " : "",
5269 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005270 ha_warning("%s.\n", tmptrash->area);
5271 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5272 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005273 free_trash_chunk(tmptrash);
5274 tmptrash = NULL;
5275 }
5276 }
5277 /* don't report anything when leaving drain mode and remaining in maintenance */
5278
5279 s->cur_admin = s->next_admin;
5280 }
5281
5282 if (!(s->next_admin & SRV_ADMF_MAINT)) {
5283 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
5284 /* drain state is applied only if not yet in maint */
5285
5286 s->last_change = now.tv_sec;
5287 if (px->lbprm.set_server_status_down)
5288 px->lbprm.set_server_status_down(s);
5289
5290 /* we might have streams queued on this server and waiting for
5291 * a connection. Those which are redispatchable will be queued
5292 * to another server or to the proxy itself.
5293 */
5294 xferred = pendconn_redistribute(s);
5295
5296 tmptrash = alloc_trash_chunk();
5297 if (tmptrash) {
5298 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
5299 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5300 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5301
5302 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
5303
5304 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005305 ha_warning("%s.\n", tmptrash->area);
5306 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5307 tmptrash->area);
5308 send_email_alert(s, LOG_NOTICE, "%s",
5309 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005310 }
5311 free_trash_chunk(tmptrash);
5312 tmptrash = NULL;
5313 }
5314
5315 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5316 set_backend_down(s->proxy);
5317 }
5318 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
5319 /* OK completely leaving drain mode */
5320 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
5321 if (s->proxy->last_change < now.tv_sec) // ignore negative times
5322 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
5323 s->proxy->last_change = now.tv_sec;
5324 }
5325
5326 if (s->last_change < now.tv_sec) // ignore negative times
5327 s->down_time += now.tv_sec - s->last_change;
5328 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005329 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005330
5331 tmptrash = alloc_trash_chunk();
5332 if (tmptrash) {
5333 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5334 chunk_printf(tmptrash,
5335 "%sServer %s/%s is %s (leaving forced drain)",
5336 s->flags & SRV_F_BACKUP ? "Backup " : "",
5337 s->proxy->id, s->id,
5338 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5339 }
5340 else {
5341 chunk_printf(tmptrash,
5342 "%sServer %s/%s is %s (leaving drain)",
5343 s->flags & SRV_F_BACKUP ? "Backup " : "",
5344 s->proxy->id, s->id,
5345 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5346 if (s->track) /* normally it's mandatory here */
5347 chunk_appendf(tmptrash, " via %s/%s",
5348 s->track->proxy->id, s->track->id);
5349 }
5350
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005351 ha_warning("%s.\n", tmptrash->area);
5352 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5353 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005354 free_trash_chunk(tmptrash);
5355 tmptrash = NULL;
5356 }
5357
5358 /* now propagate the status change to any LB algorithms */
5359 if (px->lbprm.update_server_eweight)
5360 px->lbprm.update_server_eweight(s);
5361 else if (srv_willbe_usable(s)) {
5362 if (px->lbprm.set_server_status_up)
5363 px->lbprm.set_server_status_up(s);
5364 }
5365 else {
5366 if (px->lbprm.set_server_status_down)
5367 px->lbprm.set_server_status_down(s);
5368 }
5369 }
5370 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
5371 /* remaining in drain mode after removing one of its flags */
5372
5373 tmptrash = alloc_trash_chunk();
5374 if (tmptrash) {
5375 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5376 chunk_printf(tmptrash,
5377 "%sServer %s/%s is leaving forced drain but remains in drain mode",
5378 s->flags & SRV_F_BACKUP ? "Backup " : "",
5379 s->proxy->id, s->id);
5380
5381 if (s->track) /* normally it's mandatory here */
5382 chunk_appendf(tmptrash, " via %s/%s",
5383 s->track->proxy->id, s->track->id);
5384 }
5385 else {
5386 chunk_printf(tmptrash,
5387 "%sServer %s/%s remains in forced drain mode",
5388 s->flags & SRV_F_BACKUP ? "Backup " : "",
5389 s->proxy->id, s->id);
5390 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005391 ha_warning("%s.\n", tmptrash->area);
5392 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5393 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005394 free_trash_chunk(tmptrash);
5395 tmptrash = NULL;
5396 }
5397
5398 /* commit new admin status */
5399
5400 s->cur_admin = s->next_admin;
5401 }
5402 }
5403
5404 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02005405 *s->adm_st_chg_cause = 0;
5406}
Emeric Brun64cc49c2017-10-03 14:46:45 +02005407
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005408struct task *srv_cleanup_toremove_connections(struct task *task, void *context, unsigned short state)
5409{
5410 struct connection *conn;
5411
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005412 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005413 struct connection *, toremove_list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02005414 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005415 }
5416
5417 return task;
5418}
5419
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005420/* Move toremove_nb connections from idle_tree to toremove_list, -1 means
Olivier Houchardff1d0922020-06-29 20:15:59 +02005421 * moving them all.
5422 * Returns the number of connections moved.
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005423 *
5424 * Must be called with idle_conns_lock held.
Olivier Houchardff1d0922020-06-29 20:15:59 +02005425 */
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005426static 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 +02005427{
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005428 struct eb_node *node, *next;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005429 struct connection *conn;
5430 int i = 0;
5431
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005432 node = eb_first(idle_tree);
5433 while (node) {
5434 next = eb_next(node);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005435 if (toremove_nb != -1 && i >= toremove_nb)
5436 break;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005437
5438 conn = ebmb_entry(node, struct connection, hash_node);
5439 eb_delete(node);
5440 MT_LIST_ADDQ(toremove_list, &conn->toremove_list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005441 i++;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005442
5443 node = next;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005444 }
5445 return i;
5446}
William Dauchy6318d332020-05-02 21:52:36 +02005447/* cleanup connections for a given server
5448 * might be useful when going on forced maintenance or live changing ip/port
5449 */
William Dauchy707ad322020-05-04 13:52:40 +02005450static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02005451{
William Dauchy6318d332020-05-02 21:52:36 +02005452 int did_remove;
5453 int i;
William Dauchy6318d332020-05-02 21:52:36 +02005454
Amaury Denoyelle10d5c312021-01-06 14:28:51 +01005455 /* nothing to do if pool-max-conn is null */
5456 if (!srv->max_idle_conns)
5457 return;
5458
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005459 /* check all threads starting with ours */
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005460 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02005461 did_remove = 0;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005462 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005463 if (srv_migrate_conns_to_remove(&srv->idle_conns_tree[i], &idle_conns[i].toremove_conns, -1) > 0)
William Dauchy6318d332020-05-02 21:52:36 +02005464 did_remove = 1;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005465 if (srv_migrate_conns_to_remove(&srv->safe_conns_tree[i], &idle_conns[i].toremove_conns, -1) > 0)
Olivier Houchardff1d0922020-06-29 20:15:59 +02005466 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005467 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
William Dauchy6318d332020-05-02 21:52:36 +02005468 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005469 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005470
5471 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5472 break;
William Dauchy6318d332020-05-02 21:52:36 +02005473 }
William Dauchy6318d332020-05-02 21:52:36 +02005474}
5475
Willy Tarreau980855b2019-02-07 14:59:29 +01005476struct task *srv_cleanup_idle_connections(struct task *task, void *context, unsigned short state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005477{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005478 struct server *srv;
5479 struct eb32_node *eb;
5480 int i;
5481 unsigned int next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005482
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005483 next_wakeup = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005484 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
5485 while (1) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005486 int exceed_conns;
5487 int to_kill;
5488 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005489
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005490 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
5491 if (!eb) {
5492 /* we might have reached the end of the tree, typically because
5493 * <now_ms> is in the first half and we're first scanning the last
5494 * half. Let's loop back to the beginning of the tree now.
5495 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005496
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005497 eb = eb32_first(&idle_conn_srv);
5498 if (likely(!eb))
5499 break;
5500 }
5501 if (tick_is_lt(now_ms, eb->key)) {
5502 /* timer not expired yet, revisit it later */
5503 next_wakeup = eb->key;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005504 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005505 }
5506 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005507
5508 /* Calculate how many idle connections we want to kill :
5509 * we want to remove half the difference between the total
5510 * of established connections (used or idle) and the max
5511 * number of used connections.
5512 */
5513 curr_idle = srv->curr_idle_conns;
5514 if (curr_idle == 0)
5515 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005516 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005517 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005518
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005519 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns) / 2;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005520 if (srv->est_need_conns < srv->max_used_conns)
5521 srv->est_need_conns = srv->max_used_conns;
5522
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005523 srv->max_used_conns = srv->curr_used_conns;
5524
Willy Tarreau18ed7892020-07-02 19:05:30 +02005525 if (exceed_conns <= 0)
5526 goto remove;
5527
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005528 /* check all threads starting with ours */
5529 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005530 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005531 int j;
5532 int did_remove = 0;
5533
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005534 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
5535 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005536
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005537 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005538 j = srv_migrate_conns_to_remove(&srv->idle_conns_tree[i], &idle_conns[i].toremove_conns, max_conn);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005539 if (j > 0)
5540 did_remove = 1;
5541 if (max_conn - j > 0 &&
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005542 srv_migrate_conns_to_remove(&srv->safe_conns_tree[i], &idle_conns[i].toremove_conns, max_conn - j) > 0)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005543 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005544 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005545
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005546 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005547 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005548
5549 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5550 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005551 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005552remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005553 eb32_delete(&srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005554
5555 if (srv->curr_idle_conns) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005556 /* There are still more idle connections, add the
5557 * server back in the tree.
5558 */
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005559 srv->idle_node.key = tick_add(srv->pool_purge_delay, now_ms);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005560 eb32_insert(&idle_conn_srv, &srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005561 next_wakeup = tick_first(next_wakeup, srv->idle_node.key);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005562 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005563 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005564 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5565
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005566 task->expire = next_wakeup;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005567 return task;
5568}
Olivier Houchard88698d92019-04-16 19:07:22 +02005569
Willy Tarreau76cc6992020-07-01 18:49:24 +02005570/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
5571static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
5572 struct proxy *defpx, const char *file, int line,
5573 char **err)
5574{
5575 if (too_many_args(1, args, err, NULL))
5576 return -1;
5577
5578 if (strcmp(args[1], "on") == 0)
5579 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
5580 else if (strcmp(args[1], "off") == 0)
5581 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
5582 else {
5583 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
5584 return -1;
5585 }
5586 return 0;
5587}
5588
Olivier Houchard88698d92019-04-16 19:07:22 +02005589/* config parser for global "tune.pool-{low,high}-fd-ratio" */
5590static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
5591 struct proxy *defpx, const char *file, int line,
5592 char **err)
5593{
5594 int arg = -1;
5595
5596 if (too_many_args(1, args, err, NULL))
5597 return -1;
5598
5599 if (*(args[1]) != 0)
5600 arg = atoi(args[1]);
5601
5602 if (arg < 0 || arg > 100) {
5603 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
5604 return -1;
5605 }
5606
5607 if (args[0][10] == 'h')
5608 global.tune.pool_high_ratio = arg;
5609 else
5610 global.tune.pool_low_ratio = arg;
5611 return 0;
5612}
5613
5614/* config keyword parsers */
5615static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02005616 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02005617 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
5618 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
5619 { 0, NULL, NULL }
5620}};
5621
5622INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
5623
Baptiste Assmanna68ca962015-04-14 01:15:08 +02005624/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02005625 * Local variables:
5626 * c-indent-level: 8
5627 * c-basic-offset: 8
5628 * End:
5629 */