blob: 8019dd18ac029888253abe08b3bb5ac0724db91d [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 Tarreaueb92deb2020-06-04 10:53:16 +020030#include <haproxy/dns.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020031#include <haproxy/errors.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020032#include <haproxy/global.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020033#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020034#include <haproxy/mailers.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020035#include <haproxy/namespace.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020036#include <haproxy/port_range.h>
37#include <haproxy/protocol.h>
Willy Tarreaua55c4542020-06-04 22:59:39 +020038#include <haproxy/queue.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);
Olivier Houchardd16bfe62017-10-31 15:21:19 +010053static int srv_set_fqdn(struct server *srv, const char *fqdn, int dns_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);
Willy Tarreaubaaee002006-06-26 02:48:02 +020057
Willy Tarreau21faa912012-10-10 08:27:36 +020058/* List head of all known server keywords */
59static struct srv_kw_list srv_keywords = {
60 .list = LIST_HEAD_INIT(srv_keywords.list)
61};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020062
Willy Tarreauaf613e82020-06-05 08:40:51 +020063__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010064struct eb_root idle_conn_srv = EB_ROOT;
65struct task *idle_conn_task = NULL;
Olivier Houchard9ea5d362019-02-14 18:29:09 +010066
Frédéric Lécaille7da71292019-05-20 09:47:07 +020067/* The server names dictionary */
Thayne McCombs92149f92020-11-20 01:28:26 -070068struct dict server_key_dict = {
69 .name = "server keys",
Frédéric Lécaille7da71292019-05-20 09:47:07 +020070 .values = EB_ROOT_UNIQUE,
71};
72
Baptiste Assmannda29fe22019-06-13 13:24:29 +020073/* tree where global state_file is loaded */
Willy Tarreaufd1aa012019-12-20 17:23:40 +010074struct eb_root state_file = EB_ROOT_UNIQUE;
Baptiste Assmannda29fe22019-06-13 13:24:29 +020075
Simon Hormana3608442013-11-01 16:46:15 +090076int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020077{
Amaury Denoyellee6ba7912020-10-29 15:59:05 +010078 if ((s->cur_state != SRV_ST_STOPPED) || s->last_change >= now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020079 return s->down_time;
80
81 return now.tv_sec - s->last_change + s->down_time;
82}
Willy Tarreaubaaee002006-06-26 02:48:02 +020083
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050084int srv_lastsession(const struct server *s)
85{
86 if (s->counters.last_sess)
87 return now.tv_sec - s->counters.last_sess;
88
89 return -1;
90}
91
Simon Horman4a741432013-02-23 15:35:38 +090092int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020093{
Simon Horman4a741432013-02-23 15:35:38 +090094 const struct server *s = check->server;
95
Willy Tarreauff5ae352013-12-11 20:36:34 +010096 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090097 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010098
Emeric Brun52a91d32017-08-31 14:41:55 +020099 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +0900100 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100101
Simon Horman4a741432013-02-23 15:35:38 +0900102 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100103}
104
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100105/*
106 * Check that we did not get a hash collision.
Willy Tarreau595e7672020-10-20 17:30:08 +0200107 * Unlikely, but it can happen. The server's proxy must be at least
108 * read-locked.
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100109 */
110static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +0100111{
112 struct proxy *p = s->proxy;
113 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100114
115 for (tmpserv = p->srv; tmpserv != NULL;
116 tmpserv = tmpserv->next) {
117 if (tmpserv == s)
118 continue;
119 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
120 continue;
121 if (tmpserv->cookie &&
122 strcmp(tmpserv->cookie, s->cookie) == 0) {
123 ha_warning("We generated two equal cookies for two different servers.\n"
124 "Please change the secret key for '%s'.\n",
125 s->proxy->id);
126 }
127 }
128
129}
130
Willy Tarreau46b7f532018-08-21 11:54:26 +0200131/*
Willy Tarreau595e7672020-10-20 17:30:08 +0200132 * Must be called with the server lock held, and will read-lock the proxy.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200133 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100134void srv_set_dyncookie(struct server *s)
135{
136 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100137 char *tmpbuf;
138 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100139 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100140 size_t buffer_len;
141 int addr_len;
142 int port;
143
Willy Tarreau595e7672020-10-20 17:30:08 +0200144 HA_RWLOCK_RDLOCK(PROXY_LOCK, &p->lock);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200145
Olivier Houchard4e694042017-03-14 20:01:29 +0100146 if ((s->flags & SRV_F_COOKIESET) ||
147 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
148 s->proxy->dyncookie_key == NULL)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200149 goto out;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100150 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100151
152 if (s->addr.ss_family != AF_INET &&
153 s->addr.ss_family != AF_INET6)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200154 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100155 /*
156 * Buffer to calculate the cookie value.
157 * The buffer contains the secret key + the server IP address
158 * + the TCP port.
159 */
160 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
161 /*
162 * The TCP port should use only 2 bytes, but is stored in
163 * an unsigned int in struct server, so let's use 4, to be
164 * on the safe side.
165 */
166 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200167 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100168 memcpy(tmpbuf, p->dyncookie_key, key_len);
169 memcpy(&(tmpbuf[key_len]),
170 s->addr.ss_family == AF_INET ?
171 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
172 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
173 addr_len);
174 /*
175 * Make sure it's the same across all the load balancers,
176 * no matter their endianness.
177 */
178 port = htonl(s->svc_port);
179 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
180 hash_value = XXH64(tmpbuf, buffer_len, 0);
181 memprintf(&s->cookie, "%016llx", hash_value);
182 if (!s->cookie)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200183 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100184 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100185
186 /* Don't bother checking if the dyncookie is duplicated if
187 * the server is marked as "disabled", maybe it doesn't have
188 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100189 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100190 if (!(s->next_admin & SRV_ADMF_FMAINT))
191 srv_check_for_dup_dyncookie(s);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200192 out:
Willy Tarreau595e7672020-10-20 17:30:08 +0200193 HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &p->lock);
Olivier Houchard4e694042017-03-14 20:01:29 +0100194}
195
Willy Tarreau21faa912012-10-10 08:27:36 +0200196/*
Thayne McCombs92149f92020-11-20 01:28:26 -0700197 * Must be called with the server lock held, and will write-lock the proxy.
198 */
199static void srv_set_addr_desc(struct server *s)
200{
201 struct proxy *p = s->proxy;
202 char *key;
203
204 key = sa2str(&s->addr, s->svc_port, s->flags & SRV_F_MAPPORTS);
205
206 if (s->addr_node.key) {
Thayne McCombs24da7e12021-01-05 23:10:09 -0700207 if (key && strcmp(key, s->addr_node.key) == 0) {
Thayne McCombs92149f92020-11-20 01:28:26 -0700208 free(key);
209 return;
210 }
211
212 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
213 ebpt_delete(&s->addr_node);
214 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
215
216 free(s->addr_node.key);
217 }
218
219 s->addr_node.key = key;
220
Thayne McCombs24da7e12021-01-05 23:10:09 -0700221 if (s->addr_node.key) {
222 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
223 ebis_insert(&p->used_server_addr, &s->addr_node);
224 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
225 }
Thayne McCombs92149f92020-11-20 01:28:26 -0700226}
227
228/*
Willy Tarreau21faa912012-10-10 08:27:36 +0200229 * Registers the server keyword list <kwl> as a list of valid keywords for next
230 * parsing sessions.
231 */
232void srv_register_keywords(struct srv_kw_list *kwl)
233{
234 LIST_ADDQ(&srv_keywords.list, &kwl->list);
235}
236
237/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
238 * keyword is found with a NULL ->parse() function, then an attempt is made to
239 * find one with a valid ->parse() function. This way it is possible to declare
240 * platform-dependant, known keywords as NULL, then only declare them as valid
241 * if some options are met. Note that if the requested keyword contains an
242 * opening parenthesis, everything from this point is ignored.
243 */
244struct srv_kw *srv_find_kw(const char *kw)
245{
246 int index;
247 const char *kwend;
248 struct srv_kw_list *kwl;
249 struct srv_kw *ret = NULL;
250
251 kwend = strchr(kw, '(');
252 if (!kwend)
253 kwend = kw + strlen(kw);
254
255 list_for_each_entry(kwl, &srv_keywords.list, list) {
256 for (index = 0; kwl->kw[index].kw != NULL; index++) {
257 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
258 kwl->kw[index].kw[kwend-kw] == 0) {
259 if (kwl->kw[index].parse)
260 return &kwl->kw[index]; /* found it !*/
261 else
262 ret = &kwl->kw[index]; /* may be OK */
263 }
264 }
265 }
266 return ret;
267}
268
269/* Dumps all registered "server" keywords to the <out> string pointer. The
270 * unsupported keywords are only dumped if their supported form was not
271 * found.
272 */
273void srv_dump_kws(char **out)
274{
275 struct srv_kw_list *kwl;
276 int index;
277
Christopher Faulet784063e2020-05-18 12:14:18 +0200278 if (!out)
279 return;
280
Willy Tarreau21faa912012-10-10 08:27:36 +0200281 *out = NULL;
282 list_for_each_entry(kwl, &srv_keywords.list, list) {
283 for (index = 0; kwl->kw[index].kw != NULL; index++) {
284 if (kwl->kw[index].parse ||
285 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
286 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
287 kwl->scope,
288 kwl->kw[index].kw,
289 kwl->kw[index].skip ? " <arg>" : "",
290 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
291 kwl->kw[index].parse ? "" : " (not supported)");
292 }
293 }
294 }
295}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100296
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100297/* Parse the "backup" server keyword */
298static int srv_parse_backup(char **args, int *cur_arg,
299 struct proxy *curproxy, struct server *newsrv, char **err)
300{
301 newsrv->flags |= SRV_F_BACKUP;
302 return 0;
303}
304
Alexander Liu2a54bb72019-05-22 19:44:48 +0800305
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100306/* Parse the "cookie" server keyword */
307static int srv_parse_cookie(char **args, int *cur_arg,
308 struct proxy *curproxy, struct server *newsrv, char **err)
309{
310 char *arg;
311
312 arg = args[*cur_arg + 1];
313 if (!*arg) {
314 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
315 return ERR_ALERT | ERR_FATAL;
316 }
317
318 free(newsrv->cookie);
319 newsrv->cookie = strdup(arg);
320 newsrv->cklen = strlen(arg);
321 newsrv->flags |= SRV_F_COOKIESET;
322 return 0;
323}
324
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100325/* Parse the "disabled" server keyword */
326static int srv_parse_disabled(char **args, int *cur_arg,
327 struct proxy *curproxy, struct server *newsrv, char **err)
328{
Emeric Brun52a91d32017-08-31 14:41:55 +0200329 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
330 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100331 newsrv->check.state |= CHK_ST_PAUSED;
332 newsrv->check.health = 0;
333 return 0;
334}
335
336/* Parse the "enabled" server keyword */
337static int srv_parse_enabled(char **args, int *cur_arg,
338 struct proxy *curproxy, struct server *newsrv, char **err)
339{
Emeric Brun52a91d32017-08-31 14:41:55 +0200340 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
341 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100342 newsrv->check.state &= ~CHK_ST_PAUSED;
343 newsrv->check.health = newsrv->check.rise;
344 return 0;
345}
346
Willy Tarreau9c538e02019-01-23 10:21:49 +0100347static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
348{
349 char *arg;
350
351 arg = args[*cur_arg + 1];
352 if (!*arg) {
353 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
354 return ERR_ALERT | ERR_FATAL;
355 }
356 newsrv->max_reuse = atoi(arg);
357
358 return 0;
359}
360
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100361static 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 +0100362{
363 const char *res;
364 char *arg;
365 unsigned int time;
366
367 arg = args[*cur_arg + 1];
368 if (!*arg) {
369 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
370 return ERR_ALERT | ERR_FATAL;
371 }
372 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200373 if (res == PARSE_TIME_OVER) {
374 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
375 args[*cur_arg+1], args[*cur_arg]);
376 return ERR_ALERT | ERR_FATAL;
377 }
378 else if (res == PARSE_TIME_UNDER) {
379 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
380 args[*cur_arg+1], args[*cur_arg]);
381 return ERR_ALERT | ERR_FATAL;
382 }
383 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100384 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
385 *res, args[*cur_arg]);
386 return ERR_ALERT | ERR_FATAL;
387 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100388 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100389
390 return 0;
391}
392
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200393static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
394{
395 char *arg;
396
397 arg = args[*cur_arg + 1];
398 if (!*arg) {
399 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
400 return ERR_ALERT | ERR_FATAL;
401 }
402
403 newsrv->low_idle_conns = atoi(arg);
404 return 0;
405}
406
Olivier Houchard006e3102018-12-10 18:30:32 +0100407static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
408{
409 char *arg;
410
411 arg = args[*cur_arg + 1];
412 if (!*arg) {
413 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
414 return ERR_ALERT | ERR_FATAL;
415 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100416
Olivier Houchard006e3102018-12-10 18:30:32 +0100417 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100418 if ((int)newsrv->max_idle_conns < -1) {
419 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
420 return ERR_ALERT | ERR_FATAL;
421 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100422
423 return 0;
424}
425
Willy Tarreaudff55432012-10-10 17:51:05 +0200426/* parse the "id" server keyword */
427static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
428{
429 struct eb32_node *node;
430
431 if (!*args[*cur_arg + 1]) {
432 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
433 return ERR_ALERT | ERR_FATAL;
434 }
435
436 newsrv->puid = atol(args[*cur_arg + 1]);
437 newsrv->conf.id.key = newsrv->puid;
438
439 if (newsrv->puid <= 0) {
440 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
441 return ERR_ALERT | ERR_FATAL;
442 }
443
444 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
445 if (node) {
446 struct server *target = container_of(node, struct server, conf.id);
447 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
448 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
449 target->id);
450 return ERR_ALERT | ERR_FATAL;
451 }
452
453 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200454 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200455 return 0;
456}
457
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100458/* Parse the "namespace" server keyword */
459static int srv_parse_namespace(char **args, int *cur_arg,
460 struct proxy *curproxy, struct server *newsrv, char **err)
461{
Willy Tarreaue5733232019-05-22 19:24:06 +0200462#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100463 char *arg;
464
465 arg = args[*cur_arg + 1];
466 if (!*arg) {
467 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
468 return ERR_ALERT | ERR_FATAL;
469 }
470
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100471 if (strcmp(arg, "*") == 0) {
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100472 /* Use the namespace associated with the connection (if present). */
473 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
474 return 0;
475 }
476
477 /*
478 * As this parser may be called several times for the same 'default-server'
479 * object, or for a new 'server' instance deriving from a 'default-server'
480 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
481 */
482 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
483
484 newsrv->netns = netns_store_lookup(arg, strlen(arg));
485 if (!newsrv->netns)
486 newsrv->netns = netns_store_insert(arg);
487
488 if (!newsrv->netns) {
489 memprintf(err, "Cannot open namespace '%s'", arg);
490 return ERR_ALERT | ERR_FATAL;
491 }
492
493 return 0;
494#else
495 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
496 return ERR_ALERT | ERR_FATAL;
497#endif
498}
499
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100500/* Parse the "no-backup" server keyword */
501static int srv_parse_no_backup(char **args, int *cur_arg,
502 struct proxy *curproxy, struct server *newsrv, char **err)
503{
504 newsrv->flags &= ~SRV_F_BACKUP;
505 return 0;
506}
507
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100508
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100509/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200510static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100511{
512 srv->pp_opts &= ~flags;
513 return 0;
514}
515
516/* Parse the "no-send-proxy" server keyword */
517static int srv_parse_no_send_proxy(char **args, int *cur_arg,
518 struct proxy *curproxy, struct server *newsrv, char **err)
519{
520 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
521}
522
523/* Parse the "no-send-proxy-v2" server keyword */
524static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
525 struct proxy *curproxy, struct server *newsrv, char **err)
526{
527 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
528}
529
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200530/* Parse the "no-tfo" server keyword */
531static int srv_parse_no_tfo(char **args, int *cur_arg,
532 struct proxy *curproxy, struct server *newsrv, char **err)
533{
534 newsrv->flags &= ~SRV_F_FASTOPEN;
535 return 0;
536}
537
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100538/* Parse the "non-stick" server keyword */
539static int srv_parse_non_stick(char **args, int *cur_arg,
540 struct proxy *curproxy, struct server *newsrv, char **err)
541{
542 newsrv->flags |= SRV_F_NON_STICK;
543 return 0;
544}
545
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100546/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200547static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100548{
549 srv->pp_opts |= flags;
550 return 0;
551}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200552/* parse the "proto" server keyword */
553static int srv_parse_proto(char **args, int *cur_arg,
554 struct proxy *px, struct server *newsrv, char **err)
555{
556 struct ist proto;
557
558 if (!*args[*cur_arg + 1]) {
559 memprintf(err, "'%s' : missing value", args[*cur_arg]);
560 return ERR_ALERT | ERR_FATAL;
561 }
562 proto = ist2(args[*cur_arg + 1], strlen(args[*cur_arg + 1]));
563 newsrv->mux_proto = get_mux_proto(proto);
564 if (!newsrv->mux_proto) {
565 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
566 return ERR_ALERT | ERR_FATAL;
567 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200568 return 0;
569}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100570
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100571/* parse the "proxy-v2-options" */
572static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
573 struct proxy *px, struct server *newsrv, char **err)
574{
575 char *p, *n;
576 for (p = args[*cur_arg+1]; p; p = n) {
577 n = strchr(p, ',');
578 if (n)
579 *n++ = '\0';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100580 if (strcmp(p, "ssl") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100581 newsrv->pp_opts |= SRV_PP_V2_SSL;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100582 } else if (strcmp(p, "cert-cn") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100583 newsrv->pp_opts |= SRV_PP_V2_SSL;
584 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100585 } else if (strcmp(p, "cert-key") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100586 newsrv->pp_opts |= SRV_PP_V2_SSL;
587 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100588 } else if (strcmp(p, "cert-sig") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100589 newsrv->pp_opts |= SRV_PP_V2_SSL;
590 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100591 } else if (strcmp(p, "ssl-cipher") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100592 newsrv->pp_opts |= SRV_PP_V2_SSL;
593 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100594 } else if (strcmp(p, "authority") == 0) {
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100595 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100596 } else if (strcmp(p, "crc32c") == 0) {
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100597 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100598 } else if (strcmp(p, "unique-id") == 0) {
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100599 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100600 } else
601 goto fail;
602 }
603 return 0;
604 fail:
605 if (err)
606 memprintf(err, "'%s' : proxy v2 option not implemented", p);
607 return ERR_ALERT | ERR_FATAL;
608}
609
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100610/* Parse the "observe" server keyword */
611static int srv_parse_observe(char **args, int *cur_arg,
612 struct proxy *curproxy, struct server *newsrv, char **err)
613{
614 char *arg;
615
616 arg = args[*cur_arg + 1];
617 if (!*arg) {
618 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
619 return ERR_ALERT | ERR_FATAL;
620 }
621
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100622 if (strcmp(arg, "none") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100623 newsrv->observe = HANA_OBS_NONE;
624 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100625 else if (strcmp(arg, "layer4") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100626 newsrv->observe = HANA_OBS_LAYER4;
627 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100628 else if (strcmp(arg, "layer7") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100629 if (curproxy->mode != PR_MODE_HTTP) {
630 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
631 return ERR_ALERT;
632 }
633 newsrv->observe = HANA_OBS_LAYER7;
634 }
635 else {
636 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
637 "but got '%s'\n", args[*cur_arg], arg);
638 return ERR_ALERT | ERR_FATAL;
639 }
640
641 return 0;
642}
643
Frédéric Lécaille16186232017-03-14 16:42:49 +0100644/* Parse the "redir" server keyword */
645static int srv_parse_redir(char **args, int *cur_arg,
646 struct proxy *curproxy, struct server *newsrv, char **err)
647{
648 char *arg;
649
650 arg = args[*cur_arg + 1];
651 if (!*arg) {
652 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
653 return ERR_ALERT | ERR_FATAL;
654 }
655
656 free(newsrv->rdr_pfx);
657 newsrv->rdr_pfx = strdup(arg);
658 newsrv->rdr_len = strlen(arg);
659
660 return 0;
661}
662
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100663/* Parse the "send-proxy" server keyword */
664static int srv_parse_send_proxy(char **args, int *cur_arg,
665 struct proxy *curproxy, struct server *newsrv, char **err)
666{
667 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
668}
669
670/* Parse the "send-proxy-v2" server keyword */
671static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
672 struct proxy *curproxy, struct server *newsrv, char **err)
673{
674 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
675}
676
Frédéric Lécailledba97072017-03-17 15:33:50 +0100677
678/* Parse the "source" server keyword */
679static int srv_parse_source(char **args, int *cur_arg,
680 struct proxy *curproxy, struct server *newsrv, char **err)
681{
682 char *errmsg;
683 int port_low, port_high;
684 struct sockaddr_storage *sk;
Frédéric Lécailledba97072017-03-17 15:33:50 +0100685
686 errmsg = NULL;
687
688 if (!*args[*cur_arg + 1]) {
689 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
690 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
691 goto err;
692 }
693
694 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200695 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
696 &errmsg, NULL, NULL,
697 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 +0100698 if (!sk) {
699 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
700 goto err;
701 }
702
Frédéric Lécailledba97072017-03-17 15:33:50 +0100703 newsrv->conn_src.opts |= CO_SRC_BIND;
704 newsrv->conn_src.source_addr = *sk;
705
706 if (port_low != port_high) {
707 int i;
708
Frédéric Lécailledba97072017-03-17 15:33:50 +0100709 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
710 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
711 newsrv->conn_src.sport_range->ports[i] = port_low + i;
712 }
713
714 *cur_arg += 2;
715 while (*(args[*cur_arg])) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100716 if (strcmp(args[*cur_arg], "usesrc") == 0) { /* address to use outside */
Frédéric Lécailledba97072017-03-17 15:33:50 +0100717#if defined(CONFIG_HAP_TRANSPARENT)
718 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100719 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
720 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100721 goto err;
722 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100723 if (strcmp(args[*cur_arg + 1], "client") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +0100724 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
725 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
726 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100727 else if (strcmp(args[*cur_arg + 1], "clientip") == 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_CIP;
730 }
731 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
732 char *name, *end;
733
734 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +0100735 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100736 name++;
737
738 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +0100739 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +0100740 end++;
741
742 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
743 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
744 free(newsrv->conn_src.bind_hdr_name);
745 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
746 newsrv->conn_src.bind_hdr_len = end - name;
747 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
748 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
749 newsrv->conn_src.bind_hdr_occ = -1;
750
751 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +0100752 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100753 end++;
754 if (*end == ',') {
755 end++;
756 name = end;
757 if (*end == '-')
758 end++;
Willy Tarreau90807112020-02-25 08:16:33 +0100759 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100760 end++;
761 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
762 }
763
764 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100765 ha_alert("usesrc hdr_ip(name,num) does not support negative"
766 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100767 goto err;
768 }
769 }
770 else {
771 struct sockaddr_storage *sk;
772 int port1, port2;
773
774 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200775 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, NULL, NULL,
776 &errmsg, NULL, NULL,
777 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100778 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100779 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100780 goto err;
781 }
782
Frédéric Lécailledba97072017-03-17 15:33:50 +0100783 newsrv->conn_src.tproxy_addr = *sk;
784 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
785 }
786 global.last_checks |= LSTCHK_NETADM;
787 *cur_arg += 2;
788 continue;
789#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100790 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 +0100791 goto err;
792#endif /* defined(CONFIG_HAP_TRANSPARENT) */
793 } /* "usesrc" */
794
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100795 if (strcmp(args[*cur_arg], "interface") == 0) { /* specifically bind to this interface */
Frédéric Lécailledba97072017-03-17 15:33:50 +0100796#ifdef SO_BINDTODEVICE
797 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100798 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100799 goto err;
800 }
801 free(newsrv->conn_src.iface_name);
802 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
803 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
804 global.last_checks |= LSTCHK_NETADM;
805#else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100806 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100807 goto err;
808#endif
809 *cur_arg += 2;
810 continue;
811 }
812 /* this keyword in not an option of "source" */
813 break;
814 } /* while */
815
816 return 0;
817
818 err:
819 free(errmsg);
820 return ERR_ALERT | ERR_FATAL;
821}
822
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100823/* Parse the "stick" server keyword */
824static int srv_parse_stick(char **args, int *cur_arg,
825 struct proxy *curproxy, struct server *newsrv, char **err)
826{
827 newsrv->flags &= ~SRV_F_NON_STICK;
828 return 0;
829}
830
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100831/* Parse the "track" server keyword */
832static int srv_parse_track(char **args, int *cur_arg,
833 struct proxy *curproxy, struct server *newsrv, char **err)
834{
835 char *arg;
836
837 arg = args[*cur_arg + 1];
838 if (!*arg) {
839 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
840 return ERR_ALERT | ERR_FATAL;
841 }
842
843 free(newsrv->trackit);
844 newsrv->trackit = strdup(arg);
845
846 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800847}
848
849/* Parse the "socks4" server keyword */
850static int srv_parse_socks4(char **args, int *cur_arg,
851 struct proxy *curproxy, struct server *newsrv, char **err)
852{
853 char *errmsg;
854 int port_low, port_high;
855 struct sockaddr_storage *sk;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800856
857 errmsg = NULL;
858
859 if (!*args[*cur_arg + 1]) {
860 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
861 goto err;
862 }
863
864 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200865 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
866 &errmsg, NULL, NULL,
867 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_CONNECT);
Alexander Liu2a54bb72019-05-22 19:44:48 +0800868 if (!sk) {
869 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
870 goto err;
871 }
872
Alexander Liu2a54bb72019-05-22 19:44:48 +0800873 newsrv->flags |= SRV_F_SOCKS4_PROXY;
874 newsrv->socks4_addr = *sk;
875
Alexander Liu2a54bb72019-05-22 19:44:48 +0800876 return 0;
877
878 err:
879 free(errmsg);
880 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100881}
882
Frédéric Lécailledba97072017-03-17 15:33:50 +0100883
Willy Tarreau034c88c2017-01-23 23:36:45 +0100884/* parse the "tfo" server keyword */
885static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
886{
887 newsrv->flags |= SRV_F_FASTOPEN;
888 return 0;
889}
890
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200891/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200892 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200893 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200894 *
895 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200896 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200897void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200898{
Willy Tarreau87b09662015-04-03 00:22:06 +0200899 struct stream *stream, *stream_bck;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200900
Willy Tarreau87b09662015-04-03 00:22:06 +0200901 list_for_each_entry_safe(stream, stream_bck, &srv->actconns, by_srv)
902 if (stream->srv_conn == srv)
903 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200904}
905
906/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200907 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200908 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200909 *
910 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200911 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200912void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200913{
914 struct server *srv;
915
916 for (srv = px->srv; srv != NULL; srv = srv->next)
917 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200918 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200919}
920
Willy Tarreaubda92272014-05-20 21:55:30 +0200921/* Appends some information to a message string related to a server going UP or
922 * DOWN. If both <forced> and <reason> are null and the server tracks another
923 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +0200924 * If <check> is non-null, an entire string describing the check result will be
925 * appended after a comma and a space (eg: to report some information from the
926 * check that changed the state). In the other case, the string will be built
927 * using the check results stored into the struct server if present.
928 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +0200929 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200930 *
931 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200932 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200933void srv_append_status(struct buffer *msg, struct server *s,
934 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200935{
Emeric Brun5a133512017-10-19 14:42:30 +0200936 short status = s->op_st_chg.status;
937 short code = s->op_st_chg.code;
938 long duration = s->op_st_chg.duration;
939 char *desc = s->op_st_chg.reason;
940
941 if (check) {
942 status = check->status;
943 code = check->code;
944 duration = check->duration;
945 desc = check->desc;
946 }
947
948 if (status != -1) {
949 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
950
951 if (status >= HCHK_STATUS_L57DATA)
952 chunk_appendf(msg, ", code: %d", code);
953
954 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200955 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +0200956
957 chunk_appendf(msg, ", info: \"");
958
959 chunk_initlen(&src, desc, 0, strlen(desc));
960 chunk_asciiencode(msg, &src, '"');
961
962 chunk_appendf(msg, "\"");
963 }
964
965 if (duration >= 0)
966 chunk_appendf(msg, ", check duration: %ldms", duration);
967 }
968 else if (desc && *desc) {
969 chunk_appendf(msg, ", %s", desc);
970 }
971 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +0200972 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +0200973 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200974
975 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200976 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200977 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
978 " %d sessions active, %d requeued, %d remaining in queue",
979 s->proxy->srv_act, s->proxy->srv_bck,
980 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
981 s->cur_sess, xferred, s->nbpend);
982 else
983 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
984 " %d sessions requeued, %d total in queue",
985 s->proxy->srv_act, s->proxy->srv_bck,
986 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
987 xferred, s->nbpend);
988 }
989}
990
Emeric Brun5a133512017-10-19 14:42:30 +0200991/* Marks server <s> down, regardless of its checks' statuses. The server is
992 * registered in a list to postpone the counting of the remaining servers on
993 * the proxy and transfers queued streams whenever possible to other servers at
994 * a sync point. Maintenance servers are ignored. It stores the <reason> if
995 * non-null as the reason for going down or the available data from the check
996 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200997 *
998 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200999 */
Emeric Brun5a133512017-10-19 14:42:30 +02001000void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001001{
1002 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001003
Emeric Brun64cc49c2017-10-03 14:46:45 +02001004 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001005 return;
1006
Emeric Brun52a91d32017-08-31 14:41:55 +02001007 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001008 *s->op_st_chg.reason = 0;
1009 s->op_st_chg.status = -1;
1010 if (reason) {
1011 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1012 }
1013 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001014 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001015 s->op_st_chg.code = check->code;
1016 s->op_st_chg.status = check->status;
1017 s->op_st_chg.duration = check->duration;
1018 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001019
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001020 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001021 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001022
Emeric Brun9f0b4582017-10-23 14:39:51 +02001023 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001024 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001025 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001026 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001027 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001028}
1029
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001030/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001031 * in maintenance. The server is registered in a list to postpone the counting
1032 * of the remaining servers on the proxy and tries to grab requests from the
1033 * proxy at a sync point. Maintenance servers are ignored. It stores the
1034 * <reason> if non-null as the reason for going down or the available data
1035 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001036 *
1037 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001038 */
Emeric Brun5a133512017-10-19 14:42:30 +02001039void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001040{
1041 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001042
Emeric Brun64cc49c2017-10-03 14:46:45 +02001043 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001044 return;
1045
Emeric Brun52a91d32017-08-31 14:41:55 +02001046 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001047 return;
1048
Emeric Brun52a91d32017-08-31 14:41:55 +02001049 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001050 *s->op_st_chg.reason = 0;
1051 s->op_st_chg.status = -1;
1052 if (reason) {
1053 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1054 }
1055 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001056 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001057 s->op_st_chg.code = check->code;
1058 s->op_st_chg.status = check->status;
1059 s->op_st_chg.duration = check->duration;
1060 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001061
Emeric Brun64cc49c2017-10-03 14:46:45 +02001062 if (s->slowstart <= 0)
1063 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001064
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001065 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001066 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001067
Emeric Brun9f0b4582017-10-23 14:39:51 +02001068 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001069 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001070 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001071 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001072 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001073}
1074
Willy Tarreau8eb77842014-05-21 13:54:57 +02001075/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001076 * isn't in maintenance. The server is registered in a list to postpone the
1077 * counting of the remaining servers on the proxy and tries to grab requests
1078 * from the proxy. Maintenance servers are ignored. It stores the
1079 * <reason> if non-null as the reason for going down or the available data
1080 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001081 * up. Note that it makes use of the trash to build the log strings, so <reason>
1082 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001083 *
1084 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001085 */
Emeric Brun5a133512017-10-19 14:42:30 +02001086void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001087{
1088 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001089
Emeric Brun64cc49c2017-10-03 14:46:45 +02001090 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001091 return;
1092
Emeric Brun52a91d32017-08-31 14:41:55 +02001093 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001094 return;
1095
Emeric Brun52a91d32017-08-31 14:41:55 +02001096 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001097 *s->op_st_chg.reason = 0;
1098 s->op_st_chg.status = -1;
1099 if (reason) {
1100 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1101 }
1102 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001103 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001104 s->op_st_chg.code = check->code;
1105 s->op_st_chg.status = check->status;
1106 s->op_st_chg.duration = check->duration;
1107 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001108
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001109 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001110 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001111
Emeric Brun9f0b4582017-10-23 14:39:51 +02001112 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001113 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001114 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001115 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001116 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001117}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001118
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001119/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1120 * enforce either maint mode or drain mode. It is not allowed to set more than
1121 * one flag at once. The equivalent "inherited" flag is propagated to all
1122 * tracking servers. Maintenance mode disables health checks (but not agent
1123 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001124 * is done. If <cause> is non-null, it will be displayed at the end of the log
1125 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001126 *
1127 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001128 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001129void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001130{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001131 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001132
1133 if (!mode)
1134 return;
1135
1136 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001137 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001138 return;
1139
Emeric Brun52a91d32017-08-31 14:41:55 +02001140 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001141 if (cause)
1142 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1143
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001144 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001145 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001146
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001147 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001148 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1149 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001150 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001151
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001152 /* compute the inherited flag to propagate */
1153 if (mode & SRV_ADMF_MAINT)
1154 mode = SRV_ADMF_IMAINT;
1155 else if (mode & SRV_ADMF_DRAIN)
1156 mode = SRV_ADMF_IDRAIN;
1157
Emeric Brun9f0b4582017-10-23 14:39:51 +02001158 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001159 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001160 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001161 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001162 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001163}
1164
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001165/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1166 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1167 * than one flag at once. The equivalent "inherited" flag is propagated to all
1168 * tracking servers. Leaving maintenance mode re-enables health checks. When
1169 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001170 *
1171 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001172 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001173void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001174{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001175 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001176
1177 if (!mode)
1178 return;
1179
1180 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001181 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001182 return;
1183
Emeric Brun52a91d32017-08-31 14:41:55 +02001184 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001185
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001186 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001187 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001188
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001189 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001190 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1191 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001192 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001193
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001194 if (mode & SRV_ADMF_MAINT)
1195 mode = SRV_ADMF_IMAINT;
1196 else if (mode & SRV_ADMF_DRAIN)
1197 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001198
Emeric Brun9f0b4582017-10-23 14:39:51 +02001199 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001200 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001201 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001202 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001203 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001204}
1205
Willy Tarreau757478e2016-11-03 19:22:19 +01001206/* principle: propagate maint and drain to tracking servers. This is useful
1207 * upon startup so that inherited states are correct.
1208 */
1209static void srv_propagate_admin_state(struct server *srv)
1210{
1211 struct server *srv2;
1212
1213 if (!srv->trackers)
1214 return;
1215
1216 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001217 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001218 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001219 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001220
Emeric Brun52a91d32017-08-31 14:41:55 +02001221 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001222 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001223 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001224 }
1225}
1226
1227/* Compute and propagate the admin states for all servers in proxy <px>.
1228 * Only servers *not* tracking another one are considered, because other
1229 * ones will be handled when the server they track is visited.
1230 */
1231void srv_compute_all_admin_states(struct proxy *px)
1232{
1233 struct server *srv;
1234
1235 for (srv = px->srv; srv; srv = srv->next) {
1236 if (srv->track)
1237 continue;
1238 srv_propagate_admin_state(srv);
1239 }
1240}
1241
Willy Tarreaudff55432012-10-10 17:51:05 +02001242/* Note: must not be declared <const> as its list will be overwritten.
1243 * Please take care of keeping this list alphabetically sorted, doing so helps
1244 * all code contributors.
1245 * Optional keywords are also declared with a NULL ->parse() function so that
1246 * the config parser can report an appropriate error when a known keyword was
1247 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001248 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001249 */
1250static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001251 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +01001252 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001253 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1254 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001255 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Willy Tarreau9c538e02019-01-23 10:21:49 +01001256 { "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 +01001257 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001258 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001259 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1260 { "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 +02001261 { "no-tfo", srv_parse_no_tfo, 0, 1 }, /* Disable use of TCP Fast Open */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001262 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001263 { "observe", srv_parse_observe, 1, 1 }, /* Enables health adjusting based on observing communication with the server */
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001264 { "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 +01001265 { "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 +01001266 { "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 +02001267 { "proto", srv_parse_proto, 1, 1 }, /* Set the proto to use for all outgoing connections */
Emmanuel Hocdetf643b802018-02-01 15:20:32 +01001268 { "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 +01001269 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001270 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1271 { "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 +02001272 { "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 +01001273 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Olivier Houchard8d82db72019-07-04 13:34:10 +02001274 { "tfo", srv_parse_tfo, 0, 1 }, /* enable TCP Fast Open of server */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001275 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Alexander Liu2a54bb72019-05-22 19:44:48 +08001276 { "socks4", srv_parse_socks4, 1, 1 }, /* Set the socks4 proxy of the server*/
Willy Tarreaudff55432012-10-10 17:51:05 +02001277 { NULL, NULL, 0 },
1278}};
1279
Willy Tarreau0108d902018-11-25 19:14:37 +01001280INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001281
Willy Tarreau004e0452013-11-21 11:22:01 +01001282/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001283 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001284 * state is automatically disabled if the time is elapsed. If <must_update> is
1285 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001286 *
1287 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001288 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001289void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001290{
1291 struct proxy *px = sv->proxy;
1292 unsigned w;
1293
1294 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1295 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001296 if (sv->next_state == SRV_ST_STARTING)
1297 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001298 }
1299
1300 /* We must take care of not pushing the server to full throttle during slow starts.
1301 * It must also start immediately, at least at the minimal step when leaving maintenance.
1302 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001303 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001304 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1305 else
1306 w = px->lbprm.wdiv;
1307
Emeric Brun52a91d32017-08-31 14:41:55 +02001308 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001309
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001310 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001311 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001312 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001313}
1314
Willy Tarreaubaaee002006-06-26 02:48:02 +02001315/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001316 * Parses weight_str and configures sv accordingly.
1317 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001318 *
1319 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001320 */
1321const char *server_parse_weight_change_request(struct server *sv,
1322 const char *weight_str)
1323{
1324 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001325 long int w;
1326 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001327
1328 px = sv->proxy;
1329
1330 /* if the weight is terminated with '%', it is set relative to
1331 * the initial weight, otherwise it is absolute.
1332 */
1333 if (!*weight_str)
1334 return "Require <weight> or <weight%>.\n";
1335
Simon Hormanb796afa2013-02-12 10:45:53 +09001336 w = strtol(weight_str, &end, 10);
1337 if (end == weight_str)
1338 return "Empty weight string empty or preceded by garbage";
1339 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001340 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001341 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001342 /* Avoid integer overflow */
1343 if (w > 25600)
1344 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001345 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001346 if (w > 256)
1347 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001348 }
1349 else if (w < 0 || w > 256)
1350 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001351 else if (end[0] != '\0')
1352 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001353
1354 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1355 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1356
1357 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001358 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001359
1360 return NULL;
1361}
1362
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001363/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001364 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1365 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001366 * Returns:
1367 * - error string on error
1368 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001369 *
1370 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001371 */
1372const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001373 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001374{
1375 unsigned char ip[INET6_ADDRSTRLEN];
1376
1377 if (inet_pton(AF_INET6, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001378 update_server_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001379 return NULL;
1380 }
1381 if (inet_pton(AF_INET, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001382 update_server_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001383 return NULL;
1384 }
1385
1386 return "Could not understand IP address format.\n";
1387}
1388
Willy Tarreau46b7f532018-08-21 11:54:26 +02001389/*
1390 * Must be called with the server lock held.
1391 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001392const char *server_parse_maxconn_change_request(struct server *sv,
1393 const char *maxconn_str)
1394{
1395 long int v;
1396 char *end;
1397
1398 if (!*maxconn_str)
1399 return "Require <maxconn>.\n";
1400
1401 v = strtol(maxconn_str, &end, 10);
1402 if (end == maxconn_str)
1403 return "maxconn string empty or preceded by garbage";
1404 else if (end[0] != '\0')
1405 return "Trailing garbage in maxconn string";
1406
1407 if (sv->maxconn == sv->minconn) { // static maxconn
1408 sv->maxconn = sv->minconn = v;
1409 } else { // dynamic maxconn
1410 sv->maxconn = v;
1411 }
1412
1413 if (may_dequeue_tasks(sv, sv->proxy))
1414 process_srv_queue(sv);
1415
1416 return NULL;
1417}
1418
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001419#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001420static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1421 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001422{
1423 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001424 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001425 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001426 NULL,
1427 };
1428
1429 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001430 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001431
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001432 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001433}
1434
1435static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1436{
1437 struct sample_expr *expr;
1438
1439 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 +01001440 if (!expr) {
1441 memprintf(err, "error detected while parsing sni expression : %s", *err);
1442 return ERR_ALERT | ERR_FATAL;
1443 }
1444
1445 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1446 memprintf(err, "error detected while parsing sni expression : "
1447 " fetch method '%s' extracts information from '%s', "
1448 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001449 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001450 return ERR_ALERT | ERR_FATAL;
1451 }
1452
1453 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1454 release_sample_expr(newsrv->ssl_ctx.sni);
1455 newsrv->ssl_ctx.sni = expr;
1456
1457 return 0;
1458}
1459#endif
1460
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001461static 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 +01001462{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001463 char *msg = "error encountered while processing ";
1464 char *quote = "'";
1465 char *token = args[cur_arg];
1466
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001467 if (err && *err) {
1468 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001469 msg = *err;
1470 quote = "";
1471 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001472 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001473
1474 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
1475 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1476 file, linenum, args[0], args[1],
1477 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001478 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001479 ha_alert("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}
1483
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001484static void srv_conn_src_sport_range_cpy(struct server *srv,
1485 struct server *src)
1486{
1487 int range_sz;
1488
1489 range_sz = src->conn_src.sport_range->size;
1490 if (range_sz > 0) {
1491 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1492 if (srv->conn_src.sport_range != NULL) {
1493 int i;
1494
1495 for (i = 0; i < range_sz; i++) {
1496 srv->conn_src.sport_range->ports[i] =
1497 src->conn_src.sport_range->ports[i];
1498 }
1499 }
1500 }
1501}
1502
1503/*
1504 * Copy <src> server connection source settings to <srv> server everything needed.
1505 */
1506static void srv_conn_src_cpy(struct server *srv, struct server *src)
1507{
1508 srv->conn_src.opts = src->conn_src.opts;
1509 srv->conn_src.source_addr = src->conn_src.source_addr;
1510
1511 /* Source port range copy. */
1512 if (src->conn_src.sport_range != NULL)
1513 srv_conn_src_sport_range_cpy(srv, src);
1514
1515#ifdef CONFIG_HAP_TRANSPARENT
1516 if (src->conn_src.bind_hdr_name != NULL) {
1517 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1518 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1519 }
1520 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1521 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1522#endif
1523 if (src->conn_src.iface_name != NULL)
1524 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1525}
1526
1527/*
1528 * Copy <src> server SSL settings to <srv> server allocating
1529 * everything needed.
1530 */
1531#if defined(USE_OPENSSL)
1532static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1533{
1534 if (src->ssl_ctx.ca_file != NULL)
1535 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1536 if (src->ssl_ctx.crl_file != NULL)
1537 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001538
1539 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1540
1541 if (src->ssl_ctx.verify_host != NULL)
1542 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1543 if (src->ssl_ctx.ciphers != NULL)
1544 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02001545 if (src->ssl_ctx.options)
1546 srv->ssl_ctx.options = src->ssl_ctx.options;
1547 if (src->ssl_ctx.methods.flags)
1548 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
1549 if (src->ssl_ctx.methods.min)
1550 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
1551 if (src->ssl_ctx.methods.max)
1552 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
1553
Ilya Shipitsin2aa4b3a2021-01-07 11:55:45 +05001554#ifdef HAVE_SSL_CTX_SET_CIPHERSUITES
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001555 if (src->ssl_ctx.ciphersuites != NULL)
1556 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
1557#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001558 if (src->sni_expr != NULL)
1559 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001560
1561#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
1562 if (src->ssl_ctx.alpn_str) {
1563 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1564 if (srv->ssl_ctx.alpn_str) {
1565 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1566 src->ssl_ctx.alpn_len);
1567 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1568 }
1569 }
1570#endif
1571#ifdef OPENSSL_NPN_NEGOTIATED
1572 if (src->ssl_ctx.npn_str) {
1573 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1574 if (srv->ssl_ctx.npn_str) {
1575 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1576 src->ssl_ctx.npn_len);
1577 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1578 }
1579 }
1580#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001581}
1582#endif
1583
1584/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001585 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001586 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001587 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001588 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001589static int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001590{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001591 char *hostname_dn;
1592 int hostname_len, hostname_dn_len;
1593
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001594 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001595 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001596
Christopher Faulet67957bd2017-09-27 11:00:59 +02001597 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001598 hostname_dn = trash.area;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001599 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
1600 hostname_dn, trash.size);
1601 if (hostname_dn_len == -1)
1602 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001603
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001604
Christopher Faulet67957bd2017-09-27 11:00:59 +02001605 free(srv->hostname);
1606 free(srv->hostname_dn);
1607 srv->hostname = strdup(hostname);
1608 srv->hostname_dn = strdup(hostname_dn);
1609 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001610 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001611 goto err;
1612
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001613 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001614
1615 err:
Christopher Faulet67957bd2017-09-27 11:00:59 +02001616 free(srv->hostname); srv->hostname = NULL;
1617 free(srv->hostname_dn); srv->hostname_dn = NULL;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001618 return -1;
1619}
1620
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001621/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001622 * Copy <src> server settings to <srv> server allocating
1623 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001624 * This function is not supposed to be called at any time, but only
1625 * during server settings parsing or during server allocations from
1626 * a server template, and just after having calloc()'ed a new server.
1627 * So, <src> may only be a default server (when parsing server settings)
1628 * or a server template (during server allocations from a server template).
1629 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1630 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001631 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001632static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001633{
1634 /* Connection source settings copy */
1635 srv_conn_src_cpy(srv, src);
1636
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001637 if (srv_tmpl) {
1638 srv->addr = src->addr;
1639 srv->svc_port = src->svc_port;
1640 }
1641
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001642 srv->pp_opts = src->pp_opts;
1643 if (src->rdr_pfx != NULL) {
1644 srv->rdr_pfx = strdup(src->rdr_pfx);
1645 srv->rdr_len = src->rdr_len;
1646 }
1647 if (src->cookie != NULL) {
1648 srv->cookie = strdup(src->cookie);
1649 srv->cklen = src->cklen;
1650 }
1651 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01001652 srv->check.addr = src->check.addr;
1653 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001654 srv->check.use_ssl = src->check.use_ssl;
1655 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01001656 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01001657 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05001658 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001659 /* Note: 'flags' field has potentially been already initialized. */
1660 srv->flags |= src->flags;
1661 srv->do_check = src->do_check;
1662 srv->do_agent = src->do_agent;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001663 srv->check.inter = src->check.inter;
1664 srv->check.fastinter = src->check.fastinter;
1665 srv->check.downinter = src->check.downinter;
1666 srv->agent.use_ssl = src->agent.use_ssl;
1667 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001668
1669 if (src->agent.tcpcheck_rules) {
1670 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
1671 if (srv->agent.tcpcheck_rules) {
1672 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
1673 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
1674 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
1675 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
1676 &src->agent.tcpcheck_rules->preset_vars);
1677 }
1678 }
1679
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001680 srv->agent.inter = src->agent.inter;
1681 srv->agent.fastinter = src->agent.fastinter;
1682 srv->agent.downinter = src->agent.downinter;
1683 srv->maxqueue = src->maxqueue;
1684 srv->minconn = src->minconn;
1685 srv->maxconn = src->maxconn;
1686 srv->slowstart = src->slowstart;
1687 srv->observe = src->observe;
1688 srv->onerror = src->onerror;
1689 srv->onmarkeddown = src->onmarkeddown;
1690 srv->onmarkedup = src->onmarkedup;
1691 if (src->trackit != NULL)
1692 srv->trackit = strdup(src->trackit);
1693 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1694 srv->uweight = srv->iweight = src->iweight;
1695
1696 srv->check.send_proxy = src->check.send_proxy;
1697 /* health: up, but will fall down at first failure */
1698 srv->check.rise = srv->check.health = src->check.rise;
1699 srv->check.fall = src->check.fall;
1700
1701 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001702 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1703 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1704 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001705 srv->check.state |= CHK_ST_PAUSED;
1706 srv->check.health = 0;
1707 }
1708
1709 /* health: up but will fall down at first failure */
1710 srv->agent.rise = srv->agent.health = src->agent.rise;
1711 srv->agent.fall = src->agent.fall;
1712
1713 if (src->resolvers_id != NULL)
1714 srv->resolvers_id = strdup(src->resolvers_id);
1715 srv->dns_opts.family_prio = src->dns_opts.family_prio;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02001716 srv->dns_opts.accept_duplicate_ip = src->dns_opts.accept_duplicate_ip;
Daniel Corbettf8716912019-11-17 09:48:56 -05001717 srv->dns_opts.ignore_weight = src->dns_opts.ignore_weight;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001718 if (srv->dns_opts.family_prio == AF_UNSPEC)
1719 srv->dns_opts.family_prio = AF_INET6;
1720 memcpy(srv->dns_opts.pref_net,
1721 src->dns_opts.pref_net,
1722 sizeof srv->dns_opts.pref_net);
1723 srv->dns_opts.pref_net_nb = src->dns_opts.pref_net_nb;
1724
1725 srv->init_addr_methods = src->init_addr_methods;
1726 srv->init_addr = src->init_addr;
1727#if defined(USE_OPENSSL)
1728 srv_ssl_settings_cpy(srv, src);
1729#endif
1730#ifdef TCP_USER_TIMEOUT
1731 srv->tcp_ut = src->tcp_ut;
1732#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001733 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001734 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001735 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01001736 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01001737 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001738
Olivier Houchard8da5f982017-08-04 18:35:36 +02001739 if (srv_tmpl)
1740 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001741
1742 srv->check.via_socks4 = src->check.via_socks4;
1743 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001744}
1745
William Lallemand313bfd12018-10-26 14:47:32 +02001746struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001747{
1748 struct server *srv;
1749
1750 srv = calloc(1, sizeof *srv);
1751 if (!srv)
1752 return NULL;
1753
1754 srv->obj_type = OBJ_TYPE_SERVER;
1755 srv->proxy = proxy;
1756 LIST_INIT(&srv->actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04001757 srv->pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02001758
Emeric Brun52a91d32017-08-31 14:41:55 +02001759 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001760 srv->last_change = now.tv_sec;
1761
Christopher Faulet38290462020-04-21 11:46:40 +02001762 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001763 srv->check.status = HCHK_STATUS_INI;
1764 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01001765 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02001766 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001767
Christopher Faulet38290462020-04-21 11:46:40 +02001768 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001769 srv->agent.status = HCHK_STATUS_INI;
1770 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01001771 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001772 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
Frédéric Lécaillef46c10c2020-11-23 14:29:28 +01001773#if defined(USE_QUIC)
1774 srv->cids = EB_ROOT_UNIQUE;
1775#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001776
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01001777 srv->extra_counters = NULL;
1778
Willy Tarreau975b1552019-06-06 16:25:55 +02001779 /* please don't put default server settings here, they are set in
1780 * init_default_instance().
1781 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001782 return srv;
1783}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001784
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001785#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1786static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
1787 struct server *srv, struct proxy *proxy)
1788{
1789 int ret;
1790 char *err = NULL;
1791
1792 if (!srv->sni_expr)
1793 return 0;
1794
1795 ret = server_parse_sni_expr(srv, proxy, &err);
1796 if (!ret)
1797 return 0;
1798
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001799 display_parser_err(file, linenum, args, cur_arg, ret, &err);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001800 free(err);
1801
1802 return ret;
1803}
1804#endif
1805
1806/*
1807 * Server initializations finalization.
1808 * Initialize health check, agent check and SNI expression if enabled.
1809 * Must not be called for a default server instance.
1810 */
1811static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
1812 struct server *srv, struct proxy *px)
1813{
Christopher Fauletb3b53522020-04-27 11:17:10 +02001814#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001815 int ret;
Christopher Fauletb3b53522020-04-27 11:17:10 +02001816#endif
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001817
Christopher Faulet8892e5d2020-03-26 19:48:20 +01001818 if (srv->do_check && srv->trackit) {
1819 ha_alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1820 file, linenum);
1821 return ERR_ALERT | ERR_FATAL;
1822 }
1823
1824 if (srv->do_agent && !srv->agent.port) {
1825 ha_alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
1826 file, linenum, srv->id);
1827 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001828 }
1829
1830#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1831 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
1832 return ret;
1833#endif
1834
1835 if (srv->flags & SRV_F_BACKUP)
1836 px->srv_bck++;
1837 else
1838 px->srv_act++;
1839 srv_lb_commit_status(srv);
1840
1841 return 0;
1842}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001843
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001844/*
1845 * Parse as much as possible such a range string argument: low[-high]
1846 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
1847 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
1848 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
1849 * Returns 0 if succeeded, -1 if not.
1850 */
1851static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
1852{
1853 char *nb_high_arg;
1854
1855 *nb_high = 0;
1856 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001857 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001858
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001859 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001860 *nb_high_arg++ = '\0';
1861 *nb_high = atoi(nb_high_arg);
1862 }
1863 else {
1864 *nb_high += *nb_low;
1865 *nb_low = 1;
1866 }
1867
1868 if (*nb_low < 0 || *nb_high < *nb_low)
1869 return -1;
1870
1871 return 0;
1872}
1873
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001874static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
1875{
1876 chunk_printf(&trash, "%s%d", prefix, nb);
1877 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001878 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001879}
1880
1881/*
1882 * Initialize as much as possible servers from <srv> server template.
1883 * Note that a server template is a special server with
1884 * a few different parameters than a server which has
1885 * been parsed mostly the same way as a server.
Joseph Herlant44466822018-11-15 08:57:51 -08001886 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001887 * 'srv' template included.
1888 */
1889static int server_template_init(struct server *srv, struct proxy *px)
1890{
1891 int i;
1892 struct server *newsrv;
1893
1894 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 +02001895 newsrv = new_server(px);
1896 if (!newsrv)
1897 goto err;
1898
Christopher Faulet75bef002020-11-02 22:04:55 +01001899 newsrv->conf.file = strdup(srv->conf.file);
1900 newsrv->conf.line = srv->conf.line;
1901
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001902 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001903 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001904#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1905 if (newsrv->sni_expr) {
1906 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
1907 if (!newsrv->ssl_ctx.sni)
1908 goto err;
1909 }
1910#endif
1911 /* Set this new server ID. */
1912 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
1913
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001914 /* Linked backwards first. This will be restablished after parsing. */
1915 newsrv->next = px->srv;
1916 px->srv = newsrv;
1917 }
1918 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1919
1920 return i - srv->tmpl_info.nb_low;
1921
1922 err:
1923 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1924 if (newsrv) {
1925#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1926 release_sample_expr(newsrv->ssl_ctx.sni);
1927#endif
1928 free_check(&newsrv->agent);
1929 free_check(&newsrv->check);
1930 }
1931 free(newsrv);
1932 return i - srv->tmpl_info.nb_low;
1933}
1934
Emeric Brund3db3842020-07-21 16:54:36 +02001935int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy,
1936 struct proxy *defproxy, int parse_addr, int in_peers_section, int initial_resolve)
Willy Tarreau272adea2014-03-31 10:39:59 +02001937{
1938 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001939 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001940 char *errmsg = NULL;
1941 int err_code = 0;
1942 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02001943 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001944
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001945 if (strcmp(args[0], "server") == 0 ||
1946 strcmp(args[0], "peer") == 0 ||
1947 strcmp(args[0], "default-server") == 0 ||
1948 strcmp(args[0], "server-template") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02001949 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001950 int defsrv = (*args[0] == 'd');
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001951 int srv = !defsrv && (*args[0] == 'p' || strcmp(args[0], "server") == 0);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001952 int srv_tmpl = !defsrv && !srv;
1953 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02001954
1955 if (!defsrv && curproxy == defproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001956 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001957 err_code |= ERR_ALERT | ERR_FATAL;
1958 goto out;
1959 }
Christopher Faulete3bdc812021-01-13 13:14:13 +01001960 else if (failifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL)) {
1961 err_code |= ERR_ALERT | ERR_FATAL;
1962 goto out;
1963 }
Willy Tarreau272adea2014-03-31 10:39:59 +02001964
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001965 /* There is no mandatory first arguments for default server. */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01001966 if (srv && parse_addr) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001967 if (!*args[2]) {
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +02001968 if (in_peers_section) {
1969 return 0;
1970 }
1971 else {
1972 /* 'server' line number of argument check. */
1973 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1974 file, linenum, args[0]);
1975 err_code |= ERR_ALERT | ERR_FATAL;
1976 goto out;
1977 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001978 }
1979
1980 err = invalid_char(args[1]);
1981 }
1982 else if (srv_tmpl) {
1983 if (!*args[3]) {
1984 /* 'server-template' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001985 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 +02001986 file, linenum, args[0]);
1987 err_code |= ERR_ALERT | ERR_FATAL;
1988 goto out;
1989 }
1990
1991 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001992 }
1993
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001994 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001995 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 +02001996 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001997 err_code |= ERR_ALERT | ERR_FATAL;
1998 goto out;
1999 }
2000
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002001 cur_arg = 2;
2002 if (srv_tmpl) {
2003 /* Parse server-template <nb | range> arg. */
2004 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002005 ha_alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002006 file, linenum, args[0], args[cur_arg]);
2007 err_code |= ERR_ALERT | ERR_FATAL;
2008 goto out;
2009 }
2010 cur_arg++;
2011 }
2012
Willy Tarreau272adea2014-03-31 10:39:59 +02002013 if (!defsrv) {
2014 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002015 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002016
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002017 newsrv = new_server(curproxy);
2018 if (!newsrv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002019 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Willy Tarreau272adea2014-03-31 10:39:59 +02002020 err_code |= ERR_ALERT | ERR_ABORT;
2021 goto out;
2022 }
2023
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002024 if (srv_tmpl) {
2025 newsrv->tmpl_info.nb_low = tmpl_range_low;
2026 newsrv->tmpl_info.nb_high = tmpl_range_high;
2027 }
2028
Willy Tarreau272adea2014-03-31 10:39:59 +02002029 /* the servers are linked backwards first */
2030 newsrv->next = curproxy->srv;
2031 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02002032 newsrv->conf.file = strdup(file);
2033 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002034 /* Note: for a server template, its id is its prefix.
2035 * This is a temporary id which will be used for server allocations to come
2036 * after parsing.
2037 */
2038 if (srv)
2039 newsrv->id = strdup(args[1]);
2040 else
2041 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002042
2043 /* several ways to check the port component :
2044 * - IP => port=+0, relative (IPv4 only)
2045 * - IP: => port=+0, relative
2046 * - IP:N => port=N, absolute
2047 * - IP:+N => port=+N, relative
2048 * - IP:-N => port=-N, relative
2049 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002050 if (!parse_addr)
2051 goto skip_addr;
2052
Willy Tarreau65ec4e32020-09-16 19:17:08 +02002053 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, NULL, NULL,
2054 &errmsg, NULL, &fqdn,
2055 (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 +02002056 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002057 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau272adea2014-03-31 10:39:59 +02002058 err_code |= ERR_ALERT | ERR_FATAL;
2059 goto out;
2060 }
2061
Willy Tarreau272adea2014-03-31 10:39:59 +02002062 if (!port1 || !port2) {
2063 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002064 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002065 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002066
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002067 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002068 if (fqdn) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002069 if (fqdn[0] == '_') { /* SRV record */
Olivier Houchard8da5f982017-08-04 18:35:36 +02002070 /* Check if a SRV request already exists, and if not, create it */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002071 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
2072 newsrv->srvrq = new_dns_srvrq(newsrv, fqdn);
2073 if (newsrv->srvrq == NULL) {
Olivier Houchard8da5f982017-08-04 18:35:36 +02002074 err_code |= ERR_ALERT | ERR_FATAL;
2075 goto out;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002076 }
2077 }
2078 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002079 ha_alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
Christopher Faulet67957bd2017-09-27 11:00:59 +02002080 file, linenum, newsrv->id);
2081 err_code |= ERR_ALERT | ERR_FATAL;
2082 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002083 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002084 }
2085
Willy Tarreau272adea2014-03-31 10:39:59 +02002086 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002087 newsrv->svc_port = port;
Thayne McCombs92149f92020-11-20 01:28:26 -07002088 // we don't need to lock the server here, because
2089 // we are in the process of initializing
2090 srv_set_addr_desc(newsrv);
Willy Tarreau272adea2014-03-31 10:39:59 +02002091
Olivier Houchard8da5f982017-08-04 18:35:36 +02002092 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002093 ha_alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002094 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002095 err_code |= ERR_ALERT | ERR_FATAL;
2096 goto out;
2097 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002098
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002099 cur_arg++;
2100 skip_addr:
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002101 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002102 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002103 HA_SPIN_INIT(&newsrv->lock);
Willy Tarreau272adea2014-03-31 10:39:59 +02002104 } else {
2105 newsrv = &curproxy->defsrv;
2106 cur_arg = 1;
Thierry Fournierada34842016-02-17 21:25:09 +01002107 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002108 newsrv->dns_opts.accept_duplicate_ip = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002109 }
2110
2111 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002112 if (strcmp(args[cur_arg], "init-addr") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002113 char *p, *end;
2114 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002115 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002116
2117 newsrv->init_addr_methods = 0;
2118 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2119
2120 for (p = args[cur_arg + 1]; *p; p = end) {
2121 /* cut on next comma */
2122 for (end = p; *end && *end != ','; end++);
2123 if (*end)
2124 *(end++) = 0;
2125
Willy Tarreau4310d362016-11-02 15:05:56 +01002126 memset(&sa, 0, sizeof(sa));
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002127 if (strcmp(p, "libc") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002128 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2129 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002130 else if (strcmp(p, "last") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002131 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2132 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002133 else if (strcmp(p, "none") == 0) {
Willy Tarreau37ebe122016-11-04 15:17:58 +01002134 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2135 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002136 else if (str2ip2(p, &sa, 0)) {
2137 if (is_addr(&newsrv->init_addr)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002138 ha_alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
Willy Tarreau4310d362016-11-02 15:05:56 +01002139 file, linenum, args[cur_arg], p);
2140 err_code |= ERR_ALERT | ERR_FATAL;
2141 goto out;
2142 }
2143 newsrv->init_addr = sa;
2144 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2145 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002146 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002147 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 +02002148 file, linenum, args[cur_arg], p);
2149 err_code |= ERR_ALERT | ERR_FATAL;
2150 goto out;
2151 }
2152 if (!done) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002153 ha_alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002154 file, linenum, args[cur_arg], p);
2155 err_code |= ERR_ALERT | ERR_FATAL;
2156 goto out;
2157 }
2158 }
2159 cur_arg += 2;
2160 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002161 else if (strcmp(args[cur_arg], "resolvers") == 0) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002162 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002163 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2164 cur_arg += 2;
2165 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002166 else if (strcmp(args[cur_arg], "resolve-opts") == 0) {
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002167 char *p, *end;
2168
2169 for (p = args[cur_arg + 1]; *p; p = end) {
2170 /* cut on next comma */
2171 for (end = p; *end && *end != ','; end++);
2172 if (*end)
2173 *(end++) = 0;
2174
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002175 if (strcmp(p, "allow-dup-ip") == 0) {
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002176 newsrv->dns_opts.accept_duplicate_ip = 1;
2177 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002178 else if (strcmp(p, "ignore-weight") == 0) {
Daniel Corbettf8716912019-11-17 09:48:56 -05002179 newsrv->dns_opts.ignore_weight = 1;
2180 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002181 else if (strcmp(p, "prevent-dup-ip") == 0) {
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002182 newsrv->dns_opts.accept_duplicate_ip = 0;
2183 }
2184 else {
Daniel Corbettf8716912019-11-17 09:48:56 -05002185 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 +02002186 file, linenum, args[cur_arg], p);
2187 err_code |= ERR_ALERT | ERR_FATAL;
2188 goto out;
2189 }
2190 }
2191
2192 cur_arg += 2;
2193 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002194 else if (strcmp(args[cur_arg], "resolve-prefer") == 0) {
2195 if (strcmp(args[cur_arg + 1], "ipv4") == 0)
Thierry Fournierada34842016-02-17 21:25:09 +01002196 newsrv->dns_opts.family_prio = AF_INET;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002197 else if (strcmp(args[cur_arg + 1], "ipv6") == 0)
Thierry Fournierada34842016-02-17 21:25:09 +01002198 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002199 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002200 ha_alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002201 file, linenum, args[cur_arg]);
2202 err_code |= ERR_ALERT | ERR_FATAL;
2203 goto out;
2204 }
2205 cur_arg += 2;
2206 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002207 else if (strcmp(args[cur_arg], "resolve-net") == 0) {
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002208 char *p, *e;
2209 unsigned char mask;
2210 struct dns_options *opt;
2211
2212 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002213 ha_alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002214 file, linenum, args[cur_arg]);
2215 err_code |= ERR_ALERT | ERR_FATAL;
2216 goto out;
2217 }
2218
2219 opt = &newsrv->dns_opts;
2220
2221 /* Split arguments by comma, and convert it from ipv4 or ipv6
2222 * string network in in_addr or in6_addr.
2223 */
2224 p = args[cur_arg + 1];
2225 e = p;
2226 while (*p != '\0') {
Joseph Herlant44466822018-11-15 08:57:51 -08002227 /* If no room available, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002228 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002229 ha_alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002230 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2231 err_code |= ERR_ALERT | ERR_FATAL;
2232 goto out;
2233 }
2234 /* look for end or comma. */
2235 while (*e != ',' && *e != '\0')
2236 e++;
2237 if (*e == ',') {
2238 *e = '\0';
2239 e++;
2240 }
2241 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2242 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2243 /* Try to convert input string from ipv4 or ipv6 network. */
2244 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2245 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2246 &mask)) {
2247 /* Try to convert input string from ipv6 network. */
2248 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2249 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2250 } else {
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002251 /* All network conversions fail, return error. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002252 ha_alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002253 file, linenum, args[cur_arg], p);
2254 err_code |= ERR_ALERT | ERR_FATAL;
2255 goto out;
2256 }
2257 opt->pref_net_nb++;
2258 p = e;
2259 }
2260
2261 cur_arg += 2;
2262 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002263 else if (strcmp(args[cur_arg], "weight") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002264 int w;
2265 w = atol(args[cur_arg + 1]);
2266 if (w < 0 || w > SRV_UWGHT_MAX) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002267 ha_alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002268 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2269 err_code |= ERR_ALERT | ERR_FATAL;
2270 goto out;
2271 }
2272 newsrv->uweight = newsrv->iweight = w;
2273 cur_arg += 2;
2274 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002275 else if (strcmp(args[cur_arg], "log-proto") == 0) {
2276 if (strcmp(args[cur_arg + 1], "legacy") == 0)
Emeric Brun97556472020-05-30 01:42:45 +02002277 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002278 else if (strcmp(args[cur_arg + 1], "octet-count") == 0)
Emeric Brun97556472020-05-30 01:42:45 +02002279 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
2280 else {
2281 ha_alert("parsing [%s:%d]: '%s' expects one of 'legacy' or "
2282 "'octet-count' but got '%s'\n",
2283 file, linenum, args[cur_arg], args[cur_arg + 1]);
2284 err_code |= ERR_ALERT | ERR_FATAL;
2285 goto out;
2286 }
2287 cur_arg += 2;
2288 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002289 else if (strcmp(args[cur_arg], "minconn") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002290 newsrv->minconn = atol(args[cur_arg + 1]);
2291 cur_arg += 2;
2292 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002293 else if (strcmp(args[cur_arg], "maxconn") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002294 newsrv->maxconn = atol(args[cur_arg + 1]);
2295 cur_arg += 2;
2296 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002297 else if (strcmp(args[cur_arg], "maxqueue") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002298 newsrv->maxqueue = atol(args[cur_arg + 1]);
2299 cur_arg += 2;
2300 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002301 else if (strcmp(args[cur_arg], "slowstart") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002302 /* slowstart is stored in seconds */
2303 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02002304
2305 if (err == PARSE_TIME_OVER) {
2306 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).\n",
2307 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2308 err_code |= ERR_ALERT | ERR_FATAL;
2309 goto out;
2310 }
2311 else if (err == PARSE_TIME_UNDER) {
2312 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.\n",
2313 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2314 err_code |= ERR_ALERT | ERR_FATAL;
2315 goto out;
2316 }
2317 else if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002318 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002319 file, linenum, *err, newsrv->id);
2320 err_code |= ERR_ALERT | ERR_FATAL;
2321 goto out;
2322 }
2323 newsrv->slowstart = (val + 999) / 1000;
2324 cur_arg += 2;
2325 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002326 else if (strcmp(args[cur_arg], "on-error") == 0) {
2327 if (strcmp(args[cur_arg + 1], "fastinter") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002328 newsrv->onerror = HANA_ONERR_FASTINTER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002329 else if (strcmp(args[cur_arg + 1], "fail-check") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002330 newsrv->onerror = HANA_ONERR_FAILCHK;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002331 else if (strcmp(args[cur_arg + 1], "sudden-death") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002332 newsrv->onerror = HANA_ONERR_SUDDTH;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002333 else if (strcmp(args[cur_arg + 1], "mark-down") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002334 newsrv->onerror = HANA_ONERR_MARKDWN;
2335 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002336 ha_alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
Willy Tarreau272adea2014-03-31 10:39:59 +02002337 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2338 file, linenum, args[cur_arg], args[cur_arg + 1]);
2339 err_code |= ERR_ALERT | ERR_FATAL;
2340 goto out;
2341 }
2342
2343 cur_arg += 2;
2344 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002345 else if (strcmp(args[cur_arg], "on-marked-down") == 0) {
2346 if (strcmp(args[cur_arg + 1], "shutdown-sessions") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002347 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2348 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002349 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002350 file, linenum, args[cur_arg], args[cur_arg + 1]);
2351 err_code |= ERR_ALERT | ERR_FATAL;
2352 goto out;
2353 }
2354
2355 cur_arg += 2;
2356 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002357 else if (strcmp(args[cur_arg], "on-marked-up") == 0) {
2358 if (strcmp(args[cur_arg + 1], "shutdown-backup-sessions") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002359 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2360 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002361 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002362 file, linenum, args[cur_arg], args[cur_arg + 1]);
2363 err_code |= ERR_ALERT | ERR_FATAL;
2364 goto out;
2365 }
2366
2367 cur_arg += 2;
2368 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002369 else if (strcmp(args[cur_arg], "error-limit") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002370 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002371 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002372 file, linenum, args[cur_arg]);
2373 err_code |= ERR_ALERT | ERR_FATAL;
2374 goto out;
2375 }
2376
2377 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2378
2379 if (newsrv->consecutive_errors_limit <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002380 ha_alert("parsing [%s:%d]: %s has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002381 file, linenum, args[cur_arg]);
2382 err_code |= ERR_ALERT | ERR_FATAL;
2383 goto out;
2384 }
2385 cur_arg += 2;
2386 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002387 else if (strcmp(args[cur_arg], "usesrc") == 0) { /* address to use outside: needs "source" first */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002388 ha_alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002389 file, linenum, "usesrc", "source");
2390 err_code |= ERR_ALERT | ERR_FATAL;
2391 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002392 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002393 else {
2394 static int srv_dumped;
2395 struct srv_kw *kw;
2396 char *err;
2397
2398 kw = srv_find_kw(args[cur_arg]);
2399 if (kw) {
2400 char *err = NULL;
2401 int code;
2402
2403 if (!kw->parse) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002404 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 +02002405 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002406 if (kw->skip != -1)
2407 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002408 err_code |= ERR_ALERT | ERR_FATAL;
2409 goto out;
2410 }
2411
2412 if (defsrv && !kw->default_ok) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002413 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002414 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002415 if (kw->skip != -1)
2416 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002417 err_code |= ERR_ALERT;
2418 continue;
2419 }
2420
2421 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2422 err_code |= code;
2423
2424 if (code) {
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002425 display_parser_err(file, linenum, args, cur_arg, code, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002426 if (code & ERR_FATAL) {
2427 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002428 if (kw->skip != -1)
2429 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002430 goto out;
2431 }
2432 }
2433 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002434 if (kw->skip != -1)
2435 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002436 continue;
2437 }
2438
2439 err = NULL;
2440 if (!srv_dumped) {
2441 srv_dump_kws(&err);
2442 indent_msg(&err, 4);
2443 srv_dumped = 1;
2444 }
2445
Christopher Faulet767a84b2017-11-24 16:50:31 +01002446 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002447 file, linenum, args[0], args[1], args[cur_arg],
2448 err ? " Registered keywords :" : "", err ? err : "");
2449 free(err);
2450
2451 err_code |= ERR_ALERT | ERR_FATAL;
2452 goto out;
2453 }
2454 }
2455
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002456 if (!defsrv)
2457 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2458 if (err_code & ERR_FATAL)
2459 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002460 if (srv_tmpl)
2461 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002462 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002463 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002464 return 0;
2465
2466 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002467 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002468 free(errmsg);
2469 return err_code;
2470}
2471
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002472/* Returns a pointer to the first server matching either id <id>.
2473 * NULL is returned if no match is found.
2474 * the lookup is performed in the backend <bk>
2475 */
2476struct server *server_find_by_id(struct proxy *bk, int id)
2477{
2478 struct eb32_node *eb32;
2479 struct server *curserver;
2480
2481 if (!bk || (id ==0))
2482 return NULL;
2483
2484 /* <bk> has no backend capabilities, so it can't have a server */
2485 if (!(bk->cap & PR_CAP_BE))
2486 return NULL;
2487
2488 curserver = NULL;
2489
2490 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2491 if (eb32)
2492 curserver = container_of(eb32, struct server, conf.id);
2493
2494 return curserver;
2495}
2496
2497/* Returns a pointer to the first server matching either name <name>, or id
2498 * if <name> starts with a '#'. NULL is returned if no match is found.
2499 * the lookup is performed in the backend <bk>
2500 */
2501struct server *server_find_by_name(struct proxy *bk, const char *name)
2502{
2503 struct server *curserver;
2504
2505 if (!bk || !name)
2506 return NULL;
2507
2508 /* <bk> has no backend capabilities, so it can't have a server */
2509 if (!(bk->cap & PR_CAP_BE))
2510 return NULL;
2511
2512 curserver = NULL;
2513 if (*name == '#') {
2514 curserver = server_find_by_id(bk, atoi(name + 1));
2515 if (curserver)
2516 return curserver;
2517 }
2518 else {
2519 curserver = bk->srv;
2520
2521 while (curserver && (strcmp(curserver->id, name) != 0))
2522 curserver = curserver->next;
2523
2524 if (curserver)
2525 return curserver;
2526 }
2527
2528 return NULL;
2529}
2530
2531struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2532{
2533 struct server *byname;
2534 struct server *byid;
2535
2536 if (!name && !id)
2537 return NULL;
2538
2539 if (diff)
2540 *diff = 0;
2541
2542 byname = byid = NULL;
2543
2544 if (name) {
2545 byname = server_find_by_name(bk, name);
2546 if (byname && (!id || byname->puid == id))
2547 return byname;
2548 }
2549
2550 /* remaining possibilities :
2551 * - name not set
2552 * - name set but not found
2553 * - name found but ID doesn't match
2554 */
2555 if (id) {
2556 byid = server_find_by_id(bk, id);
2557 if (byid) {
2558 if (byname) {
2559 /* use id only if forced by configuration */
2560 if (byid->flags & SRV_F_FORCED_ID) {
2561 if (diff)
2562 *diff |= 2;
2563 return byid;
2564 }
2565 else {
2566 if (diff)
2567 *diff |= 1;
2568 return byname;
2569 }
2570 }
2571
2572 /* remaining possibilities:
2573 * - name not set
2574 * - name set but not found
2575 */
2576 if (name && diff)
2577 *diff |= 2;
2578 return byid;
2579 }
2580
2581 /* id bot found */
2582 if (byname) {
2583 if (diff)
2584 *diff |= 1;
2585 return byname;
2586 }
2587 }
2588
2589 return NULL;
2590}
2591
Willy Tarreau46b7f532018-08-21 11:54:26 +02002592/* Update a server state using the parameters available in the params list.
2593 *
2594 * Grabs the server lock during operation.
2595 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002596static void srv_update_state(struct server *srv, int version, char **params)
2597{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002598 char *p;
Willy Tarreau83061a82018-07-13 11:56:34 +02002599 struct buffer *msg;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002600
2601 /* fields since version 1
2602 * and common to all other upcoming versions
2603 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002604 enum srv_state srv_op_state;
2605 enum srv_admin srv_admin_state;
2606 unsigned srv_uweight, srv_iweight;
2607 unsigned long srv_last_time_change;
2608 short srv_check_status;
2609 enum chk_result srv_check_result;
2610 int srv_check_health;
2611 int srv_check_state, srv_agent_state;
2612 int bk_f_forced_id;
2613 int srv_f_forced_id;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002614 int fqdn_set_by_cli;
2615 const char *fqdn;
William Dauchyfe03e7d2021-02-03 22:30:06 +01002616 const char *port_svc_st;
2617 const char *port_check_st;
2618 unsigned int port_svc;
2619 unsigned int port_check;
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002620 char *srvrecord;
William Dauchyf6370442020-11-14 19:25:33 +01002621#ifdef USE_OPENSSL
2622 int use_ssl;
2623#endif
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002624
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002625 fqdn = NULL;
William Dauchyfe03e7d2021-02-03 22:30:06 +01002626 port_svc = port_check = 0;
Willy Tarreau31138fa2015-09-29 18:38:47 +02002627 msg = get_trash_chunk();
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002628 switch (version) {
2629 case 1:
2630 /*
2631 * now we can proceed with server's state update:
2632 * srv_addr: params[0]
2633 * srv_op_state: params[1]
2634 * srv_admin_state: params[2]
2635 * srv_uweight: params[3]
2636 * srv_iweight: params[4]
2637 * srv_last_time_change: params[5]
2638 * srv_check_status: params[6]
2639 * srv_check_result: params[7]
2640 * srv_check_health: params[8]
2641 * srv_check_state: params[9]
2642 * srv_agent_state: params[10]
2643 * bk_f_forced_id: params[11]
2644 * srv_f_forced_id: params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002645 * srv_fqdn: params[13]
Frédéric Lécaille31694712017-08-01 08:47:19 +02002646 * srv_port: params[14]
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002647 * srvrecord: params[15]
William Dauchyf6370442020-11-14 19:25:33 +01002648 * srv_use_ssl: params[16]
William Dauchyfe03e7d2021-02-03 22:30:06 +01002649 * srv_check_port: params[17]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002650 */
2651
2652 /* validating srv_op_state */
2653 p = NULL;
2654 errno = 0;
2655 srv_op_state = strtol(params[1], &p, 10);
2656 if ((p == params[1]) || errno == EINVAL || errno == ERANGE ||
2657 (srv_op_state != SRV_ST_STOPPED &&
2658 srv_op_state != SRV_ST_STARTING &&
2659 srv_op_state != SRV_ST_RUNNING &&
2660 srv_op_state != SRV_ST_STOPPING)) {
2661 chunk_appendf(msg, ", invalid srv_op_state value '%s'", params[1]);
2662 }
2663
2664 /* validating srv_admin_state */
2665 p = NULL;
2666 errno = 0;
2667 srv_admin_state = strtol(params[2], &p, 10);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002668 fqdn_set_by_cli = !!(srv_admin_state & SRV_ADMF_HMAINT);
Willy Tarreau757478e2016-11-03 19:22:19 +01002669
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002670 /* inherited statuses will be recomputed later.
2671 * Also disable SRV_ADMF_HMAINT flag (set from stats socket fqdn).
2672 */
2673 srv_admin_state &= ~SRV_ADMF_IDRAIN & ~SRV_ADMF_IMAINT & ~SRV_ADMF_HMAINT;
Willy Tarreau757478e2016-11-03 19:22:19 +01002674
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002675 if ((p == params[2]) || errno == EINVAL || errno == ERANGE ||
2676 (srv_admin_state != 0 &&
2677 srv_admin_state != SRV_ADMF_FMAINT &&
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002678 srv_admin_state != SRV_ADMF_CMAINT &&
2679 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT) &&
Willy Tarreaue1bde142016-11-03 18:33:25 +01002680 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FDRAIN) &&
Willy Tarreau757478e2016-11-03 19:22:19 +01002681 srv_admin_state != SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002682 chunk_appendf(msg, ", invalid srv_admin_state value '%s'", params[2]);
2683 }
2684
2685 /* validating srv_uweight */
2686 p = NULL;
2687 errno = 0;
2688 srv_uweight = strtol(params[3], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002689 if ((p == params[3]) || errno == EINVAL || errno == ERANGE || (srv_uweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002690 chunk_appendf(msg, ", invalid srv_uweight value '%s'", params[3]);
2691
2692 /* validating srv_iweight */
2693 p = NULL;
2694 errno = 0;
2695 srv_iweight = strtol(params[4], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002696 if ((p == params[4]) || errno == EINVAL || errno == ERANGE || (srv_iweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002697 chunk_appendf(msg, ", invalid srv_iweight value '%s'", params[4]);
2698
2699 /* validating srv_last_time_change */
2700 p = NULL;
2701 errno = 0;
2702 srv_last_time_change = strtol(params[5], &p, 10);
2703 if ((p == params[5]) || errno == EINVAL || errno == ERANGE)
2704 chunk_appendf(msg, ", invalid srv_last_time_change value '%s'", params[5]);
2705
2706 /* validating srv_check_status */
2707 p = NULL;
2708 errno = 0;
2709 srv_check_status = strtol(params[6], &p, 10);
2710 if (p == params[6] || errno == EINVAL || errno == ERANGE ||
2711 (srv_check_status >= HCHK_STATUS_SIZE))
2712 chunk_appendf(msg, ", invalid srv_check_status value '%s'", params[6]);
2713
2714 /* validating srv_check_result */
2715 p = NULL;
2716 errno = 0;
2717 srv_check_result = strtol(params[7], &p, 10);
2718 if ((p == params[7]) || errno == EINVAL || errno == ERANGE ||
2719 (srv_check_result != CHK_RES_UNKNOWN &&
2720 srv_check_result != CHK_RES_NEUTRAL &&
2721 srv_check_result != CHK_RES_FAILED &&
2722 srv_check_result != CHK_RES_PASSED &&
2723 srv_check_result != CHK_RES_CONDPASS)) {
2724 chunk_appendf(msg, ", invalid srv_check_result value '%s'", params[7]);
2725 }
2726
2727 /* validating srv_check_health */
2728 p = NULL;
2729 errno = 0;
2730 srv_check_health = strtol(params[8], &p, 10);
2731 if (p == params[8] || errno == EINVAL || errno == ERANGE)
2732 chunk_appendf(msg, ", invalid srv_check_health value '%s'", params[8]);
2733
2734 /* validating srv_check_state */
2735 p = NULL;
2736 errno = 0;
2737 srv_check_state = strtol(params[9], &p, 10);
2738 if (p == params[9] || errno == EINVAL || errno == ERANGE ||
2739 (srv_check_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2740 chunk_appendf(msg, ", invalid srv_check_state value '%s'", params[9]);
2741
2742 /* validating srv_agent_state */
2743 p = NULL;
2744 errno = 0;
2745 srv_agent_state = strtol(params[10], &p, 10);
2746 if (p == params[10] || errno == EINVAL || errno == ERANGE ||
2747 (srv_agent_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2748 chunk_appendf(msg, ", invalid srv_agent_state value '%s'", params[10]);
2749
2750 /* validating bk_f_forced_id */
2751 p = NULL;
2752 errno = 0;
2753 bk_f_forced_id = strtol(params[11], &p, 10);
2754 if (p == params[11] || errno == EINVAL || errno == ERANGE || !((bk_f_forced_id == 0) || (bk_f_forced_id == 1)))
2755 chunk_appendf(msg, ", invalid bk_f_forced_id value '%s'", params[11]);
2756
2757 /* validating srv_f_forced_id */
2758 p = NULL;
2759 errno = 0;
2760 srv_f_forced_id = strtol(params[12], &p, 10);
2761 if (p == params[12] || errno == EINVAL || errno == ERANGE || !((srv_f_forced_id == 0) || (srv_f_forced_id == 1)))
2762 chunk_appendf(msg, ", invalid srv_f_forced_id value '%s'", params[12]);
2763
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002764 /* validating srv_fqdn */
2765 fqdn = params[13];
2766 if (fqdn && *fqdn == '-')
2767 fqdn = NULL;
2768 if (fqdn && (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn))) {
2769 chunk_appendf(msg, ", invalid srv_fqdn value '%s'", params[13]);
2770 fqdn = NULL;
2771 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002772
William Dauchyfe03e7d2021-02-03 22:30:06 +01002773 port_svc_st = params[14];
2774 if (port_svc_st) {
2775 port_svc = strl2uic(port_svc_st, strlen(port_svc_st));
2776 if (port_svc > USHRT_MAX) {
2777 chunk_appendf(msg, ", invalid srv_port value '%s'", port_svc_st);
2778 port_svc_st = NULL;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002779 }
2780 }
William Dauchyfe03e7d2021-02-03 22:30:06 +01002781 port_check_st = params[17];
2782 if (port_check_st) {
2783 port_check = strl2uic(port_check_st, strlen(port_check_st));
2784 if (port_check > USHRT_MAX) {
2785 chunk_appendf(msg, ", invalid srv_port value '%s'", port_check_st);
2786 port_check_st = NULL;
2787 }
2788 }
Frédéric Lécaille31694712017-08-01 08:47:19 +02002789
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002790 /* SRV record
2791 * NOTE: in HAProxy, SRV records must start with an underscore '_'
2792 */
2793 srvrecord = params[15];
2794 if (srvrecord && *srvrecord != '_')
2795 srvrecord = NULL;
2796
William Dauchyf6370442020-11-14 19:25:33 +01002797#ifdef USE_OPENSSL
2798 use_ssl = strtol(params[16], &p, 10);
2799#endif
2800
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002801 /* don't apply anything if one error has been detected */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002802 if (msg->data)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002803 goto out;
2804
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002805 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002806 /* recover operational state and apply it to this server
2807 * and all servers tracking this one */
Jérôme Magninf57afa42019-01-20 11:27:40 +01002808 srv->check.health = srv_check_health;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002809 switch (srv_op_state) {
2810 case SRV_ST_STOPPED:
2811 srv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02002812 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002813 break;
2814 case SRV_ST_STARTING:
Jérôme Magninf57afa42019-01-20 11:27:40 +01002815 /* If rise == 1 there is no STARTING state, let's switch to
2816 * RUNNING
2817 */
2818 if (srv->check.rise == 1) {
2819 srv->check.health = srv->check.rise + srv->check.fall - 1;
2820 srv_set_running(srv, "", NULL);
2821 break;
2822 }
2823 if (srv->check.health < 1 || srv->check.health >= srv->check.rise)
2824 srv->check.health = srv->check.rise - 1;
Emeric Brun52a91d32017-08-31 14:41:55 +02002825 srv->next_state = srv_op_state;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002826 break;
2827 case SRV_ST_STOPPING:
Jérôme Magninf57afa42019-01-20 11:27:40 +01002828 /* If fall == 1 there is no STOPPING state, let's switch to
2829 * STOPPED
2830 */
2831 if (srv->check.fall == 1) {
2832 srv->check.health = 0;
2833 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
2834 break;
2835 }
2836 if (srv->check.health < srv->check.rise ||
2837 srv->check.health > srv->check.rise + srv->check.fall - 2)
2838 srv->check.health = srv->check.rise;
Emeric Brun5a133512017-10-19 14:42:30 +02002839 srv_set_stopping(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002840 break;
2841 case SRV_ST_RUNNING:
2842 srv->check.health = srv->check.rise + srv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02002843 srv_set_running(srv, "", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002844 break;
2845 }
2846
2847 /* When applying server state, the following rules apply:
2848 * - in case of a configuration change, we apply the setting from the new
2849 * configuration, regardless of old running state
2850 * - if no configuration change, we apply old running state only if old running
2851 * state is different from new configuration state
2852 */
2853 /* configuration has changed */
Emeric Brun52a91d32017-08-31 14:41:55 +02002854 if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->next_admin & SRV_ADMF_CMAINT)) {
2855 if (srv->next_admin & SRV_ADMF_CMAINT)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002856 srv_adm_set_maint(srv);
2857 else
2858 srv_adm_set_ready(srv);
2859 }
2860 /* configuration is the same, let's compate old running state and new conf state */
2861 else {
Emeric Brun52a91d32017-08-31 14:41:55 +02002862 if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002863 srv_adm_set_maint(srv);
Emeric Brun52a91d32017-08-31 14:41:55 +02002864 else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002865 srv_adm_set_ready(srv);
2866 }
2867 /* apply drain mode if server is currently enabled */
Emeric Brun52a91d32017-08-31 14:41:55 +02002868 if (!(srv->next_admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002869 /* The SRV_ADMF_FDRAIN flag is inherited when srv->iweight is 0
Willy Tarreau22cace22016-11-03 18:19:49 +01002870 * (srv->iweight is the weight set up in configuration).
2871 * There are two possible reasons for FDRAIN to have been present :
2872 * - previous config weight was zero
2873 * - "set server b/s drain" was sent to the CLI
2874 *
2875 * In the first case, we simply want to drop this drain state
2876 * if the new weight is not zero anymore, meaning the administrator
2877 * has intentionally turned the weight back to a positive value to
2878 * enable the server again after an operation. In the second case,
2879 * the drain state was forced on the CLI regardless of the config's
2880 * weight so we don't want a change to the config weight to lose this
2881 * status. What this means is :
2882 * - if previous weight was 0 and new one is >0, drop the DRAIN state.
2883 * - if the previous weight was >0, keep it.
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002884 */
Willy Tarreau22cace22016-11-03 18:19:49 +01002885 if (srv_iweight > 0 || srv->iweight == 0)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002886 srv_adm_set_drain(srv);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002887 }
2888
2889 srv->last_change = date.tv_sec - srv_last_time_change;
2890 srv->check.status = srv_check_status;
2891 srv->check.result = srv_check_result;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002892
2893 /* Only case we want to apply is removing ENABLED flag which could have been
2894 * done by the "disable health" command over the stats socket
2895 */
2896 if ((srv->check.state & CHK_ST_CONFIGURED) &&
2897 (srv_check_state & CHK_ST_CONFIGURED) &&
2898 !(srv_check_state & CHK_ST_ENABLED))
2899 srv->check.state &= ~CHK_ST_ENABLED;
2900
2901 /* Only case we want to apply is removing ENABLED flag which could have been
2902 * done by the "disable agent" command over the stats socket
2903 */
2904 if ((srv->agent.state & CHK_ST_CONFIGURED) &&
2905 (srv_agent_state & CHK_ST_CONFIGURED) &&
2906 !(srv_agent_state & CHK_ST_ENABLED))
2907 srv->agent.state &= ~CHK_ST_ENABLED;
2908
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002909 /* We want to apply the previous 'running' weight (srv_uweight) only if there
2910 * was no change in the configuration: both previous and new iweight are equals
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002911 *
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002912 * It means that a configuration file change has precedence over a unix socket change
2913 * for server's weight
2914 *
2915 * by default, HAProxy applies the following weight when parsing the configuration
2916 * srv->uweight = srv->iweight
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002917 */
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002918 if (srv_iweight == srv->iweight) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002919 srv->uweight = srv_uweight;
2920 }
Willy Tarreau3ff577e2018-08-02 11:48:52 +02002921 server_recalc_eweight(srv, 1);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002922
Willy Tarreaue5a60682016-11-09 14:54:53 +01002923 /* load server IP address */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002924 if (strcmp(params[0], "-") != 0)
Daniel Corbett9215ffa2018-05-19 19:43:24 -04002925 srv->lastaddr = strdup(params[0]);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002926
2927 if (fqdn && srv->hostname) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002928 if (strcmp(srv->hostname, fqdn) == 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002929 /* Here we reset the 'set from stats socket FQDN' flag
2930 * to support such transitions:
2931 * Let's say initial FQDN value is foo1 (in configuration file).
2932 * - FQDN changed from stats socket, from foo1 to foo2 value,
2933 * - FQDN changed again from file configuration (with the same previous value
2934 set from stats socket, from foo1 to foo2 value),
2935 * - reload for any other reason than a FQDN modification,
2936 * the configuration file FQDN matches the fqdn server state file value.
2937 * So we must reset the 'set from stats socket FQDN' flag to be consistent with
Joseph Herlant44466822018-11-15 08:57:51 -08002938 * any further FQDN modification.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002939 */
Emeric Brun52a91d32017-08-31 14:41:55 +02002940 srv->next_admin &= ~SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002941 }
2942 else {
2943 /* If the FDQN has been changed from stats socket,
2944 * apply fqdn state file value (which is the value set
2945 * from stats socket).
Baptiste Assmann13a92322019-06-07 09:40:55 +02002946 * Also ensure the runtime resolver will process this resolution.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002947 */
2948 if (fqdn_set_by_cli) {
Olivier Houchardd16bfe62017-10-31 15:21:19 +01002949 srv_set_fqdn(srv, fqdn, 0);
Baptiste Assmann13a92322019-06-07 09:40:55 +02002950 srv->flags &= ~SRV_F_NO_RESOLUTION;
Emeric Brun52a91d32017-08-31 14:41:55 +02002951 srv->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002952 }
2953 }
2954 }
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002955 /* If all the conditions below are validated, this means
2956 * we're evaluating a server managed by SRV resolution
2957 */
2958 else if (fqdn && !srv->hostname && srvrecord) {
2959 int res;
2960
2961 /* we can't apply previous state if SRV record has changed */
2962 if (srv->srvrq && strcmp(srv->srvrq->name, srvrecord) != 0) {
2963 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);
2964 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2965 goto out;
2966 }
2967
2968 /* create or find a SRV resolution for this srv record */
2969 if (srv->srvrq == NULL && (srv->srvrq = find_srvrq_by_name(srvrecord, srv->proxy)) == NULL)
2970 srv->srvrq = new_dns_srvrq(srv, srvrecord);
2971 if (srv->srvrq == NULL) {
2972 chunk_appendf(msg, ", can't create or find SRV resolution '%s' for server '%s'", srvrecord, srv->id);
2973 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2974 goto out;
2975 }
2976
2977 /* prepare DNS resolution for this server */
2978 res = srv_prepare_for_resolution(srv, fqdn);
2979 if (res == -1) {
2980 chunk_appendf(msg, ", can't allocate memory for DNS resolution for server '%s'", srv->id);
2981 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2982 goto out;
2983 }
2984
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002985 /* Unset SRV_F_MAPPORTS for SRV records.
2986 * SRV_F_MAPPORTS is unfortunately set by parse_server()
2987 * because no ports are provided in the configuration file.
2988 * This is because HAProxy will use the port found into the SRV record.
2989 */
2990 srv->flags &= ~SRV_F_MAPPORTS;
2991 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002992
William Dauchyfe03e7d2021-02-03 22:30:06 +01002993 if (port_svc_st)
2994 srv->svc_port = port_svc;
2995
2996 if (!srv->check.port)
2997 srv->check.port = port_check;
William Dauchyf6370442020-11-14 19:25:33 +01002998
2999#ifdef USE_OPENSSL
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003000 /* configure ssl if connection has been initiated at startup */
William Dauchyf6370442020-11-14 19:25:33 +01003001 if (srv->ssl_ctx.ctx != NULL)
3002 ssl_sock_set_srv(srv, use_ssl);
3003#endif
3004
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003005 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Frédéric Lécaille31694712017-08-01 08:47:19 +02003006
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003007 break;
3008 default:
3009 chunk_appendf(msg, ", version '%d' not supported", version);
3010 }
3011
3012 out:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003013 if (msg->data) {
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003014 chunk_appendf(msg, "\n");
Christopher Faulet767a84b2017-11-24 16:50:31 +01003015 ha_warning("server-state application failed for server '%s/%s'%s",
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003016 srv->proxy->id, srv->id, msg->area);
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003017 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003018}
3019
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003020
3021/*
3022 * read next line from file <f> and return the server state version if one found.
3023 * If no version is found, then 0 is returned
3024 * Note that this should be the first read on <f>
3025 */
3026static int srv_state_get_version(FILE *f) {
3027 char buf[2];
3028 int ret;
3029
3030 /* first character of first line of the file must contain the version of the export */
3031 if (fgets(buf, 2, f) == NULL) {
3032 return 0;
3033 }
3034
3035 ret = atoi(buf);
3036 if ((ret < SRV_STATE_FILE_VERSION_MIN) ||
3037 (ret > SRV_STATE_FILE_VERSION_MAX))
3038 return 0;
3039
3040 return ret;
3041}
3042
3043
3044/*
3045 * parses server state line stored in <buf> and supposedly in version <version>.
3046 * Set <params> and <srv_params> accordingly.
3047 * In case of error, params[0] is set to NULL.
3048 */
3049static void srv_state_parse_line(char *buf, const int version, char **params, char **srv_params)
3050{
3051 int buflen, arg, srv_arg;
3052 char *cur, *end;
3053
3054 buflen = strlen(buf);
3055 cur = buf;
3056 end = cur + buflen;
3057
3058 /* we need at least one character */
3059 if (buflen == 0) {
3060 params[0] = NULL;
3061 return;
3062 }
3063
3064 /* ignore blank characters at the beginning of the line */
Willy Tarreau90807112020-02-25 08:16:33 +01003065 while (isspace((unsigned char)*cur))
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003066 ++cur;
3067
3068 /* Ignore empty or commented lines */
3069 if (cur == end || *cur == '#') {
3070 params[0] = NULL;
3071 return;
3072 }
3073
3074 /* truncated lines */
3075 if (buf[buflen - 1] != '\n') {
3076 //ha_warning("server-state file '%s': truncated line\n", filepath);
3077 params[0] = NULL;
3078 return;
3079 }
3080
3081 /* Removes trailing '\n' */
3082 buf[buflen - 1] = '\0';
3083
3084 /* we're now ready to move the line into *srv_params[] */
3085 params[0] = cur;
3086 arg = 1;
3087 srv_arg = 0;
3088 while (*cur && arg < SRV_STATE_FILE_MAX_FIELDS) {
Willy Tarreau90807112020-02-25 08:16:33 +01003089 if (isspace((unsigned char)*cur)) {
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003090 *cur = '\0';
3091 ++cur;
Willy Tarreau90807112020-02-25 08:16:33 +01003092 while (isspace((unsigned char)*cur))
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003093 ++cur;
3094 switch (version) {
3095 case 1:
3096 /*
3097 * srv_addr: params[4] => srv_params[0]
3098 * srv_op_state: params[5] => srv_params[1]
3099 * srv_admin_state: params[6] => srv_params[2]
3100 * srv_uweight: params[7] => srv_params[3]
3101 * srv_iweight: params[8] => srv_params[4]
3102 * srv_last_time_change: params[9] => srv_params[5]
3103 * srv_check_status: params[10] => srv_params[6]
3104 * srv_check_result: params[11] => srv_params[7]
3105 * srv_check_health: params[12] => srv_params[8]
3106 * srv_check_state: params[13] => srv_params[9]
3107 * srv_agent_state: params[14] => srv_params[10]
3108 * bk_f_forced_id: params[15] => srv_params[11]
3109 * srv_f_forced_id: params[16] => srv_params[12]
3110 * srv_fqdn: params[17] => srv_params[13]
3111 * srv_port: params[18] => srv_params[14]
3112 * srvrecord: params[19] => srv_params[15]
3113 */
3114 if (arg >= 4) {
3115 srv_params[srv_arg] = cur;
3116 ++srv_arg;
3117 }
3118 break;
3119 }
3120
3121 params[arg] = cur;
3122 ++arg;
3123 }
3124 else {
3125 ++cur;
3126 }
3127 }
3128
3129 /* if line is incomplete line, then ignore it.
3130 * otherwise, update useful flags */
3131 switch (version) {
3132 case 1:
3133 if (arg < SRV_STATE_FILE_NB_FIELDS_VERSION_1) {
3134 params[0] = NULL;
3135 return;
3136 }
3137 break;
3138 }
3139
3140 return;
3141}
3142
3143
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003144/* This function parses all the proxies and only take care of the backends (since we're looking for server)
3145 * For each proxy, it does the following:
3146 * - opens its server state file (either one or local one)
3147 * - read whole file, line by line
3148 * - analyse each line to check if it matches our current backend:
3149 * - backend name matches
3150 * - backend id matches if id is forced and name doesn't match
3151 * - if the server pointed by the line is found, then state is applied
3152 *
3153 * If the running backend uuid or id differs from the state file, then HAProxy reports
3154 * a warning.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003155 *
3156 * Grabs the server's lock via srv_update_state().
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003157 */
3158void apply_server_state(void)
3159{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003160 char mybuf[SRV_STATE_LINE_MAXLEN];
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003161 char *params[SRV_STATE_FILE_MAX_FIELDS] = {0};
3162 char *srv_params[SRV_STATE_FILE_MAX_FIELDS] = {0};
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003163 int version, global_file_version;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003164 FILE *f;
3165 char *filepath;
3166 char globalfilepath[MAXPATHLEN + 1];
3167 char localfilepath[MAXPATHLEN + 1];
3168 int len, fileopenerr, globalfilepathlen, localfilepathlen;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003169 struct proxy *curproxy, *bk;
3170 struct server *srv;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003171 char *line;
3172 char *bkname, *srvname;
3173 struct state_line *st;
3174 struct ebmb_node *node, *next_node;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003175
Willy Tarreau2d067f92020-07-16 06:40:27 +02003176 f = NULL;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003177 global_file_version = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003178 globalfilepathlen = 0;
3179 /* create the globalfilepath variable */
3180 if (global.server_state_file) {
3181 /* absolute path or no base directory provided */
3182 if ((global.server_state_file[0] == '/') || (!global.server_state_base)) {
3183 len = strlen(global.server_state_file);
3184 if (len > MAXPATHLEN) {
3185 globalfilepathlen = 0;
3186 goto globalfileerror;
3187 }
3188 memcpy(globalfilepath, global.server_state_file, len);
3189 globalfilepath[len] = '\0';
3190 globalfilepathlen = len;
3191 }
3192 else if (global.server_state_base) {
3193 len = strlen(global.server_state_base);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003194 if (len > MAXPATHLEN) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003195 globalfilepathlen = 0;
3196 goto globalfileerror;
3197 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003198 memcpy(globalfilepath, global.server_state_base, len);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003199 globalfilepath[len] = 0;
3200 globalfilepathlen = len;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003201
3202 /* append a slash if needed */
3203 if (!globalfilepathlen || globalfilepath[globalfilepathlen - 1] != '/') {
3204 if (globalfilepathlen + 1 > MAXPATHLEN) {
3205 globalfilepathlen = 0;
3206 goto globalfileerror;
3207 }
3208 globalfilepath[globalfilepathlen++] = '/';
3209 }
3210
3211 len = strlen(global.server_state_file);
3212 if (globalfilepathlen + len > MAXPATHLEN) {
3213 globalfilepathlen = 0;
3214 goto globalfileerror;
3215 }
3216 memcpy(globalfilepath + globalfilepathlen, global.server_state_file, len);
3217 globalfilepathlen += len;
3218 globalfilepath[globalfilepathlen++] = 0;
3219 }
3220 }
3221 globalfileerror:
3222 if (globalfilepathlen == 0)
3223 globalfilepath[0] = '\0';
3224
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003225 /* Load global server state in a tree */
3226 if (globalfilepathlen > 0) {
3227 errno = 0;
3228 f = fopen(globalfilepath, "r");
3229 if (errno)
3230 ha_warning("Can't open global server state file '%s': %s\n", globalfilepath, strerror(errno));
Vedran Furac5d486272019-10-16 14:49:38 +02003231 if (!f)
3232 goto out_load_server_state_in_tree;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003233
3234 global_file_version = srv_state_get_version(f);
3235 if (global_file_version == 0)
3236 goto out_load_server_state_in_tree;
3237
3238 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3239 line = NULL;
3240
3241 line = strdup(mybuf);
3242 if (line == NULL)
3243 continue;
3244
3245 srv_state_parse_line(mybuf, global_file_version, params, srv_params);
3246 if (params[0] == NULL)
Willy Tarreauca7a5af2019-12-20 17:26:27 +01003247 goto nextline;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003248
3249 /* bkname */
3250 bkname = params[1];
3251 /* srvname */
3252 srvname = params[3];
3253
3254 /* key */
3255 chunk_printf(&trash, "%s %s", bkname, srvname);
3256
3257 /* store line in tree */
Willy Tarreau7d6a1fa2019-12-20 17:18:13 +01003258 st = calloc(1, sizeof(*st) + trash.data + 1);
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003259 if (st == NULL) {
3260 goto nextline;
3261 }
Willy Tarreau7d6a1fa2019-12-20 17:18:13 +01003262 memcpy(st->name_name.key, trash.area, trash.data + 1);
Willy Tarreaufd1aa012019-12-20 17:23:40 +01003263 if (ebst_insert(&state_file, &st->name_name) != &st->name_name) {
3264 /* this is a duplicate key, probably a hand-crafted file,
3265 * drop it!
3266 */
3267 goto nextline;
3268 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003269
3270 /* save line */
3271 st->line = line;
3272
3273 continue;
3274
3275 nextline:
3276 /* free up memory in case of error during the processing of the line */
3277 free(line);
3278 }
3279 }
3280 out_load_server_state_in_tree:
3281
Ilya Shipitsindc6e8a92020-07-16 02:02:40 +05003282 if (f) {
3283 fclose(f);
3284 f = NULL;
3285 }
3286
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003287 /* parse all proxies and load states form tree (global file) or from local file */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003288 for (curproxy = proxies_list; curproxy != NULL; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003289 /* servers are only in backends */
3290 if (!(curproxy->cap & PR_CAP_BE))
3291 continue;
3292 fileopenerr = 0;
3293 filepath = NULL;
3294
3295 /* search server state file path and name */
3296 switch (curproxy->load_server_state_from_file) {
3297 /* read servers state from global file */
3298 case PR_SRV_STATE_FILE_GLOBAL:
3299 /* there was an error while generating global server state file path */
3300 if (globalfilepathlen == 0)
3301 continue;
3302 filepath = globalfilepath;
3303 fileopenerr = 1;
3304 break;
3305 /* this backend has its own file */
3306 case PR_SRV_STATE_FILE_LOCAL:
3307 localfilepathlen = 0;
3308 localfilepath[0] = '\0';
3309 len = 0;
3310 /* create the localfilepath variable */
3311 /* absolute path or no base directory provided */
3312 if ((curproxy->server_state_file_name[0] == '/') || (!global.server_state_base)) {
3313 len = strlen(curproxy->server_state_file_name);
3314 if (len > MAXPATHLEN) {
3315 localfilepathlen = 0;
3316 goto localfileerror;
3317 }
3318 memcpy(localfilepath, curproxy->server_state_file_name, len);
3319 localfilepath[len] = '\0';
3320 localfilepathlen = len;
3321 }
3322 else if (global.server_state_base) {
3323 len = strlen(global.server_state_base);
3324 localfilepathlen += len;
3325
3326 if (localfilepathlen > MAXPATHLEN) {
3327 localfilepathlen = 0;
3328 goto localfileerror;
3329 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003330 memcpy(localfilepath, global.server_state_base, len);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003331 localfilepath[localfilepathlen] = 0;
3332
3333 /* append a slash if needed */
3334 if (!localfilepathlen || localfilepath[localfilepathlen - 1] != '/') {
3335 if (localfilepathlen + 1 > MAXPATHLEN) {
3336 localfilepathlen = 0;
3337 goto localfileerror;
3338 }
3339 localfilepath[localfilepathlen++] = '/';
3340 }
3341
3342 len = strlen(curproxy->server_state_file_name);
3343 if (localfilepathlen + len > MAXPATHLEN) {
3344 localfilepathlen = 0;
3345 goto localfileerror;
3346 }
3347 memcpy(localfilepath + localfilepathlen, curproxy->server_state_file_name, len);
3348 localfilepathlen += len;
3349 localfilepath[localfilepathlen++] = 0;
3350 }
3351 filepath = localfilepath;
3352 localfileerror:
3353 if (localfilepathlen == 0)
3354 localfilepath[0] = '\0';
3355
3356 break;
3357 case PR_SRV_STATE_FILE_NONE:
3358 default:
3359 continue;
3360 }
3361
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003362 /* when global file is used, we get data from the tree
3363 * Note that in such case we don't check backend name neither uuid.
3364 * Backend name can't be wrong since it's used as a key to retrieve the server state
3365 * line from the tree.
3366 */
3367 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_GLOBAL) {
3368 struct server *srv = curproxy->srv;
3369 while (srv) {
3370 struct ebmb_node *node;
3371 struct state_line *st;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003372
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003373 chunk_printf(&trash, "%s %s", curproxy->id, srv->id);
3374 node = ebst_lookup(&state_file, trash.area);
3375 if (!node)
3376 goto next;
Dragan Dosencf4fb032015-11-04 23:03:26 +01003377
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003378 st = container_of(node, struct state_line, name_name);
3379 memcpy(mybuf, st->line, strlen(st->line));
3380 mybuf[strlen(st->line)] = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003381
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003382 srv_state_parse_line(mybuf, global_file_version, params, srv_params);
3383 if (params[0] == NULL)
3384 goto next;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003385
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003386 srv_update_state(srv, global_file_version, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003387
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003388 next:
3389 srv = srv->next;
3390 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003391
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003392 continue; /* next proxy in list */
3393 }
3394 else {
3395 /* load 'local' state file */
3396 errno = 0;
3397 f = fopen(filepath, "r");
3398 if (errno && fileopenerr)
3399 ha_warning("Can't open server state file '%s': %s\n", filepath, strerror(errno));
3400 if (!f)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003401 continue;
3402
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003403 mybuf[0] = '\0';
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003404
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003405 /* first character of first line of the file must contain the version of the export */
3406 version = srv_state_get_version(f);
3407 if (version == 0) {
3408 ha_warning("Can't get version of the server state file '%s'\n", filepath);
3409 goto fileclose;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003410 }
3411
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003412 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3413 int bk_f_forced_id = 0;
3414 int check_id = 0;
3415 int check_name = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003416
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003417 srv_state_parse_line(mybuf, version, params, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003418
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003419 if (params[0] == NULL) {
3420 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003421 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003422
3423 /* if line is incomplete line, then ignore it.
3424 * otherwise, update useful flags */
3425 switch (version) {
3426 case 1:
3427 bk_f_forced_id = (atoi(params[15]) & PR_O_FORCED_ID);
3428 check_id = (atoi(params[0]) == curproxy->uuid);
3429 check_name = (strcmp(curproxy->id, params[1]) == 0);
3430 break;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003431 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003432
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003433 bk = curproxy;
3434
3435 /* if backend can't be found, let's continue */
3436 if (!check_id && !check_name)
3437 continue;
3438 else if (!check_id && check_name) {
3439 ha_warning("backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3440 send_log(bk, LOG_NOTICE, "backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3441 }
3442 else if (check_id && !check_name) {
3443 ha_warning("backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3444 send_log(bk, LOG_NOTICE, "backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3445 /* if name doesn't match, we still want to update curproxy if the backend id
3446 * was forced in previous the previous configuration */
3447 if (!bk_f_forced_id)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003448 continue;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003449 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003450
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003451 /* look for the server by its name: param[3] */
3452 srv = server_find_best_match(bk, params[3], 0, NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003453
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003454 if (!srv) {
3455 /* if no server found, then warning and continue with next line */
3456 ha_warning("can't find server '%s' in backend '%s'\n",
3457 params[3], params[1]);
3458 send_log(bk, LOG_NOTICE, "can't find server '%s' in backend '%s'\n",
3459 params[3], params[1]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003460 continue;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003461 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003462
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003463 /* now we can proceed with server's state update */
3464 srv_update_state(srv, version, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003465 }
Ilya Shipitsindc6e8a92020-07-16 02:02:40 +05003466
3467 fileclose:
3468 fclose(f);
3469
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003470 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003471 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003472
3473 /* now free memory allocated for the tree */
3474 for (node = ebmb_first(&state_file), next_node = node ? ebmb_next(node) : NULL;
3475 node;
3476 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
3477 st = container_of(node, struct state_line, name_name);
3478 ebmb_delete(&st->name_name);
3479 free(st->line);
3480 free(st);
3481 }
3482
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003483}
3484
Simon Horman7d09b9a2013-02-12 10:45:51 +09003485/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02003486 * update a server's current IP address.
3487 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
3488 * ip is in network format.
3489 * updater is a string which contains an information about the requester of the update.
3490 * updater is used if not NULL.
3491 *
3492 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003493 *
3494 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02003495 */
Thierry Fournierd35b7a62016-02-24 08:23:22 +01003496int update_server_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02003497{
Christopher Fauletd6c6b5f2020-09-08 10:27:24 +02003498 /* save the new IP family & address if necessary */
3499 switch (ip_sin_family) {
3500 case AF_INET:
3501 if (s->addr.ss_family == ip_sin_family &&
3502 !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
3503 return 0;
3504 break;
3505 case AF_INET6:
3506 if (s->addr.ss_family == ip_sin_family &&
3507 !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
3508 return 0;
3509 break;
3510 };
3511
Baptiste Assmann14e40142015-04-14 01:13:07 +02003512 /* generates a log line and a warning on stderr */
3513 if (1) {
3514 /* book enough space for both IPv4 and IPv6 */
3515 char oldip[INET6_ADDRSTRLEN];
3516 char newip[INET6_ADDRSTRLEN];
3517
3518 memset(oldip, '\0', INET6_ADDRSTRLEN);
3519 memset(newip, '\0', INET6_ADDRSTRLEN);
3520
3521 /* copy old IP address in a string */
3522 switch (s->addr.ss_family) {
3523 case AF_INET:
3524 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
3525 break;
3526 case AF_INET6:
3527 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
3528 break;
Christopher Fauletb0b76072020-09-08 10:38:40 +02003529 default:
3530 strcpy(oldip, "(none)");
3531 break;
Baptiste Assmann14e40142015-04-14 01:13:07 +02003532 };
3533
3534 /* copy new IP address in a string */
3535 switch (ip_sin_family) {
3536 case AF_INET:
3537 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
3538 break;
3539 case AF_INET6:
3540 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
3541 break;
3542 };
3543
3544 /* save log line into a buffer */
3545 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
3546 s->proxy->id, s->id, oldip, newip, updater);
3547
3548 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003549 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003550
3551 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003552 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003553 }
3554
3555 /* save the new IP family */
3556 s->addr.ss_family = ip_sin_family;
3557 /* save the new IP address */
3558 switch (ip_sin_family) {
3559 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02003560 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003561 break;
3562 case AF_INET6:
3563 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
3564 break;
3565 };
Olivier Houchard4e694042017-03-14 20:01:29 +01003566 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07003567 srv_set_addr_desc(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003568
3569 return 0;
3570}
3571
3572/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003573 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3574 *
3575 * Caller can pass its name through <updater> to get it integrated in the response message
3576 * returned by the function.
3577 *
3578 * The function first does the following, in that order:
3579 * - validates the new addr and/or port
3580 * - checks if an update is required (new IP or port is different than current ones)
3581 * - checks the update is allowed:
3582 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3583 * - allow all changes if no CHECKS are configured
3584 * - if CHECK is configured:
3585 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3586 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3587 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02003588 *
3589 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003590 */
3591const char *update_server_addr_port(struct server *s, const char *addr, const char *port, char *updater)
3592{
3593 struct sockaddr_storage sa;
3594 int ret, port_change_required;
3595 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003596 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02003597 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003598 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003599
3600 msg = get_trash_chunk();
3601 chunk_reset(msg);
3602
3603 if (addr) {
3604 memset(&sa, 0, sizeof(struct sockaddr_storage));
3605 if (str2ip2(addr, &sa, 0) == NULL) {
3606 chunk_printf(msg, "Invalid addr '%s'", addr);
3607 goto out;
3608 }
3609
3610 /* changes are allowed on AF_INET* families only */
3611 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3612 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3613 goto out;
3614 }
3615
3616 /* collecting data currently setup */
3617 memset(current_addr, '\0', sizeof(current_addr));
3618 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3619 /* changes are allowed on AF_INET* families only */
3620 if ((ret != AF_INET) && (ret != AF_INET6)) {
3621 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3622 goto out;
3623 }
3624
3625 /* applying ADDR changes if required and allowed
3626 * ipcmp returns 0 when both ADDR are the same
3627 */
3628 if (ipcmp(&s->addr, &sa) == 0) {
3629 chunk_appendf(msg, "no need to change the addr");
3630 goto port;
3631 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003632 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003633 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003634
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003635 /* update report for caller */
3636 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3637 }
3638
3639 port:
3640 if (port) {
3641 char sign = '\0';
3642 char *endptr;
3643
3644 if (addr)
3645 chunk_appendf(msg, ", ");
3646
3647 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003648 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003649
3650 /* check if PORT change is required */
3651 port_change_required = 0;
3652
3653 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003654 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003655 new_port = strtol(port, &endptr, 10);
3656 if ((errno != 0) || (port == endptr)) {
3657 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3658 goto out;
3659 }
3660
3661 /* check if caller triggers a port mapped or offset */
3662 if (sign == '-' || (sign == '+')) {
3663 /* check if server currently uses port map */
3664 if (!(s->flags & SRV_F_MAPPORTS)) {
3665 /* switch from fixed port to port map mandatorily triggers
3666 * a port change */
3667 port_change_required = 1;
3668 /* check is configured
3669 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3670 * prevent PORT change if check doesn't have it's dedicated port while switching
3671 * to port mapping */
William Dauchy69f118d2021-02-03 22:30:07 +01003672 if (!s->check.port) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003673 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.");
3674 goto out;
3675 }
3676 }
3677 /* we're already using port maps */
3678 else {
3679 port_change_required = current_port != new_port;
3680 }
3681 }
3682 /* fixed port */
3683 else {
3684 port_change_required = current_port != new_port;
3685 }
3686
3687 /* applying PORT changes if required and update response message */
3688 if (port_change_required) {
3689 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003690 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003691 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003692
3693 /* prepare message */
3694 chunk_appendf(msg, "port changed from '");
3695 if (s->flags & SRV_F_MAPPORTS)
3696 chunk_appendf(msg, "+");
3697 chunk_appendf(msg, "%d' to '", current_port);
3698
3699 if (sign == '-') {
3700 s->flags |= SRV_F_MAPPORTS;
3701 chunk_appendf(msg, "%c", sign);
3702 /* just use for result output */
3703 new_port = -new_port;
3704 }
3705 else if (sign == '+') {
3706 s->flags |= SRV_F_MAPPORTS;
3707 chunk_appendf(msg, "%c", sign);
3708 }
3709 else {
3710 s->flags &= ~SRV_F_MAPPORTS;
3711 }
3712
3713 chunk_appendf(msg, "%d'", new_port);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003714 }
3715 else {
3716 chunk_appendf(msg, "no need to change the port");
3717 }
3718 }
3719
3720out:
William Dauchy6318d332020-05-02 21:52:36 +02003721 if (changed) {
3722 /* force connection cleanup on the given server */
3723 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01003724 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07003725 srv_set_addr_desc(s);
William Dauchy6318d332020-05-02 21:52:36 +02003726 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003727 if (updater)
3728 chunk_appendf(msg, " by '%s'", updater);
3729 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003730 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003731}
3732
3733
3734/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003735 * update server status based on result of name resolution
3736 * returns:
3737 * 0 if server status is updated
3738 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003739 *
3740 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003741 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003742int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003743{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003744 struct dns_resolvers *resolvers = s->resolvers;
3745 struct dns_resolution *resolution = s->dns_requester->resolution;
3746 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003747
Jerome Magnin012261a2020-07-28 13:38:22 +02003748 /* If resolution is NULL we're dealing with SRV records Additional records */
3749 if (resolution == NULL) {
Baptiste Assmann87138c32020-08-04 10:57:21 +02003750 /* since this server has an IP, it can go back in production */
3751 if (has_no_ip == 0) {
3752 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3753 return 1;
3754 }
3755
Jerome Magnin012261a2020-07-28 13:38:22 +02003756 if (s->next_admin & SRV_ADMF_RMAINT)
3757 return 1;
3758
3759 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
3760 return 0;
3761 }
3762
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003763 switch (resolution->status) {
3764 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003765 /* status when HAProxy has just (re)started.
3766 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003767 break;
3768
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003769 case RSLV_STATUS_VALID:
3770 /*
3771 * resume health checks
3772 * server will be turned back on if health check is safe
3773 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003774 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003775 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003776 return 1;
3777 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3778 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003779 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003780 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003781
Emeric Brun52a91d32017-08-31 14:41:55 +02003782 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003783 return 1;
3784 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3785 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3786 s->proxy->id, s->id);
3787
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003788 ha_warning("%s.\n", trash.area);
3789 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003790 return 0;
3791
3792 case RSLV_STATUS_NX:
3793 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003794 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3795 if (!tick_is_expired(exp, now_ms))
3796 break;
3797
3798 if (s->next_admin & SRV_ADMF_RMAINT)
3799 return 1;
3800 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3801 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003802
3803 case RSLV_STATUS_TIMEOUT:
3804 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003805 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3806 if (!tick_is_expired(exp, now_ms))
3807 break;
3808
3809 if (s->next_admin & SRV_ADMF_RMAINT)
3810 return 1;
3811 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3812 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003813
3814 case RSLV_STATUS_REFUSED:
3815 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003816 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3817 if (!tick_is_expired(exp, now_ms))
3818 break;
3819
3820 if (s->next_admin & SRV_ADMF_RMAINT)
3821 return 1;
3822 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3823 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003824
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003825 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003826 /* stop server if resolution failed for a long enough period */
3827 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3828 if (!tick_is_expired(exp, now_ms))
3829 break;
3830
3831 if (s->next_admin & SRV_ADMF_RMAINT)
3832 return 1;
3833 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3834 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003835 }
3836
3837 return 1;
3838}
3839
3840/*
3841 * Server Name Resolution valid response callback
3842 * It expects:
3843 * - <nameserver>: the name server which answered the valid response
3844 * - <response>: buffer containing a valid DNS response
3845 * - <response_len>: size of <response>
3846 * It performs the following actions:
3847 * - ignore response if current ip found and server family not met
3848 * - update with first new ip found if family is met and current IP is not found
3849 * returns:
3850 * 0 on error
3851 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003852 *
3853 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003854 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003855int snr_resolution_cb(struct dns_requester *requester, struct dns_nameserver *nameserver)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003856{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003857 struct server *s = NULL;
3858 struct dns_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003859 void *serverip, *firstip;
3860 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003861 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003862 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003863 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003864
Christopher Faulet67957bd2017-09-27 11:00:59 +02003865 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003866 if (!s)
3867 return 1;
3868
Christopher Faulet67957bd2017-09-27 11:00:59 +02003869 resolution = s->dns_requester->resolution;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003870
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003871 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003872 firstip = NULL; /* pointer to the first valid response found */
3873 /* it will be used as the new IP if a change is required */
3874 firstip_sin_family = AF_UNSPEC;
3875 serverip = NULL; /* current server IP address */
3876
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003877 /* initializing server IP pointer */
3878 server_sin_family = s->addr.ss_family;
3879 switch (server_sin_family) {
3880 case AF_INET:
3881 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3882 break;
3883
3884 case AF_INET6:
3885 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3886 break;
3887
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003888 case AF_UNSPEC:
3889 break;
3890
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003891 default:
3892 goto invalid;
3893 }
3894
Baptiste Assmann729c9012017-05-22 15:13:10 +02003895 ret = dns_get_ip_from_response(&resolution->response, &s->dns_opts,
Thierry Fournierada34842016-02-17 21:25:09 +01003896 serverip, server_sin_family, &firstip,
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003897 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003898
3899 switch (ret) {
3900 case DNS_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003901 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003902
3903 case DNS_UPD_SRVIP_NOT_FOUND:
3904 goto save_ip;
3905
3906 case DNS_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003907 goto invalid;
3908
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003909 case DNS_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003910 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003911 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003912
Baptiste Assmannfad03182015-10-28 02:03:32 +01003913 case DNS_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003914 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003915 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003916 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003917
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003918 default:
3919 goto invalid;
3920
3921 }
3922
3923 save_ip:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003924 if (nameserver) {
Amaury Denoyellefbd0bc92020-10-05 11:49:46 +02003925 nameserver->counters->update++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003926 /* save the first ip we found */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003927 chunk_printf(chk, "%s/%s", nameserver->resolvers->id, nameserver->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003928 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003929 else
3930 chunk_printf(chk, "DNS cache");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003931 update_server_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003932
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003933 update_status:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003934 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003935 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003936
3937 invalid:
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003938 if (nameserver) {
Amaury Denoyellefbd0bc92020-10-05 11:49:46 +02003939 nameserver->counters->invalid++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003940 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003941 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003942 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003943 return 0;
3944}
3945
3946/*
3947 * Server Name Resolution error management callback
3948 * returns:
3949 * 0 on error
3950 * 1 when no error or safe ignore
Willy Tarreau46b7f532018-08-21 11:54:26 +02003951 *
3952 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003953 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003954int snr_resolution_error_cb(struct dns_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003955{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003956 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003957
Christopher Faulet67957bd2017-09-27 11:00:59 +02003958 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003959 if (!s)
3960 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003961 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003962 snr_update_srv_status(s, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003963 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003964 return 1;
3965}
3966
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003967/*
3968 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003969 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003970 * It returns a pointer to the first server found or NULL if <ip> is not yet
3971 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003972 *
3973 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003974 */
3975struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3976{
3977 struct server *tmpsrv;
3978 struct proxy *be;
3979
3980 if (!srv)
3981 return NULL;
3982
3983 be = srv->proxy;
3984 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003985 /* we found the current server is the same, ignore it */
3986 if (srv == tmpsrv)
3987 continue;
3988
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003989 /* We want to compare the IP in the record with the IP of the servers in the
3990 * same backend, only if:
3991 * * DNS resolution is enabled on the server
3992 * * the hostname used for the resolution by our server is the same than the
3993 * one used for the server found in the backend
3994 * * the server found in the backend is not our current server
3995 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003996 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003997 if ((tmpsrv->hostname_dn == NULL) ||
3998 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
3999 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01004000 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004001 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004002 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01004003 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004004
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004005 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01004006 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004007 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004008 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01004009 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004010
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004011 /* At this point, we have 2 different servers using the same DNS hostname
4012 * for their respective resolution.
4013 */
4014 if (*ip_family == tmpsrv->addr.ss_family &&
4015 ((tmpsrv->addr.ss_family == AF_INET &&
4016 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
4017 (tmpsrv->addr.ss_family == AF_INET6 &&
4018 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004019 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004020 return tmpsrv;
4021 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004022 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004023 }
4024
Emeric Brune9fd6b52017-11-02 17:20:39 +01004025
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004026 return NULL;
4027}
4028
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004029/* Sets the server's address (srv->addr) from srv->hostname using the libc's
4030 * resolver. This is suited for initial address configuration. Returns 0 on
4031 * success otherwise a non-zero error code. In case of error, *err_code, if
4032 * not NULL, is filled up.
4033 */
4034int srv_set_addr_via_libc(struct server *srv, int *err_code)
4035{
4036 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004037 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01004038 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004039 return 1;
4040 }
4041 return 0;
4042}
4043
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004044/* Set the server's FDQN (->hostname) from <hostname>.
4045 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004046 *
4047 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004048 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004049int srv_set_fqdn(struct server *srv, const char *hostname, int dns_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004050{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004051 struct dns_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004052 char *hostname_dn;
4053 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004054
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02004055 /* Note that the server lock is already held. */
4056 if (!srv->resolvers)
4057 return -1;
4058
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004059 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004060 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004061 /* run time DNS resolution was not active for this server
4062 * and we can't enable it at run time for now.
4063 */
4064 if (!srv->dns_requester)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004065 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004066
4067 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004068 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004069 hostname_dn = trash.area;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004070 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
4071 hostname_dn, trash.size);
4072 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004073 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004074
Christopher Faulet67957bd2017-09-27 11:00:59 +02004075 resolution = srv->dns_requester->resolution;
4076 if (resolution &&
4077 resolution->hostname_dn &&
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004078 strcmp(resolution->hostname_dn, hostname_dn) == 0)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004079 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004080
Christopher Faulet67957bd2017-09-27 11:00:59 +02004081 dns_unlink_resolution(srv->dns_requester);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004082
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004083 free(srv->hostname);
4084 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004085 srv->hostname = strdup(hostname);
4086 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004087 srv->hostname_dn_len = hostname_dn_len;
4088 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004089 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004090
Baptiste Assmann13a92322019-06-07 09:40:55 +02004091 if (srv->flags & SRV_F_NO_RESOLUTION)
4092 goto end;
4093
Olivier Houchard55dcdf42017-11-06 15:15:04 +01004094 if (dns_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004095 goto err;
4096
4097 end:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004098 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004099 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004100 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02004101
4102 err:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004103 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004104 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02004105 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004106}
4107
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004108/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
4109 * from the state file. This is suited for initial address configuration.
4110 * Returns 0 on success otherwise a non-zero error code. In case of error,
4111 * *err_code, if not NULL, is filled up.
4112 */
4113static int srv_apply_lastaddr(struct server *srv, int *err_code)
4114{
4115 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
4116 if (err_code)
4117 *err_code |= ERR_WARN;
4118 return 1;
4119 }
4120 return 0;
4121}
4122
Willy Tarreau25e51522016-11-04 15:10:17 +01004123/* returns 0 if no error, otherwise a combination of ERR_* flags */
4124static int srv_iterate_initaddr(struct server *srv)
4125{
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004126 char *name = srv->hostname;
Willy Tarreau25e51522016-11-04 15:10:17 +01004127 int return_code = 0;
4128 int err_code;
4129 unsigned int methods;
4130
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004131 /* If no addr and no hostname set, get the name from the DNS SRV request */
4132 if (!name && srv->srvrq)
4133 name = srv->srvrq->name;
4134
Willy Tarreau25e51522016-11-04 15:10:17 +01004135 methods = srv->init_addr_methods;
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004136 if (!methods) {
4137 /* otherwise default to "last,libc" */
Willy Tarreau25e51522016-11-04 15:10:17 +01004138 srv_append_initaddr(&methods, SRV_IADDR_LAST);
4139 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004140 if (srv->resolvers_id) {
4141 /* dns resolution is configured, add "none" to not fail on startup */
4142 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4143 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004144 }
4145
Willy Tarreau3eed10e2016-11-07 21:03:16 +01004146 /* "-dr" : always append "none" so that server addresses resolution
4147 * failures are silently ignored, this is convenient to validate some
4148 * configs out of their environment.
4149 */
4150 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
4151 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4152
Willy Tarreau25e51522016-11-04 15:10:17 +01004153 while (methods) {
4154 err_code = 0;
4155 switch (srv_get_next_initaddr(&methods)) {
4156 case SRV_IADDR_LAST:
4157 if (!srv->lastaddr)
4158 continue;
4159 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004160 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004161 return_code |= err_code;
4162 break;
4163
4164 case SRV_IADDR_LIBC:
4165 if (!srv->hostname)
4166 continue;
4167 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004168 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004169 return_code |= err_code;
4170 break;
4171
Willy Tarreau37ebe122016-11-04 15:17:58 +01004172 case SRV_IADDR_NONE:
4173 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004174 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004175 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004176 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004177 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01004178 return return_code;
4179
Willy Tarreau4310d362016-11-02 15:05:56 +01004180 case SRV_IADDR_IP:
4181 ipcpy(&srv->init_addr, &srv->addr);
4182 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004183 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 +01004184 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau4310d362016-11-02 15:05:56 +01004185 }
Olivier Houchard4e694042017-03-14 20:01:29 +01004186 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01004187
Willy Tarreau25e51522016-11-04 15:10:17 +01004188 default: /* unhandled method */
4189 break;
4190 }
4191 }
4192
4193 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004194 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004195 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau25e51522016-11-04 15:10:17 +01004196 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01004197 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004198 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004199 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004200 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004201
4202 return_code |= ERR_ALERT | ERR_FATAL;
4203 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01004204out:
4205 srv_set_dyncookie(srv);
Thayne McCombs92149f92020-11-20 01:28:26 -07004206 srv_set_addr_desc(srv);
Olivier Houchard4e694042017-03-14 20:01:29 +01004207 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01004208}
4209
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004210/*
4211 * This function parses all backends and all servers within each backend
4212 * and performs servers' addr resolution based on information provided by:
4213 * - configuration file
4214 * - server-state file (states provided by an 'old' haproxy process)
4215 *
4216 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
4217 */
4218int srv_init_addr(void)
4219{
4220 struct proxy *curproxy;
4221 int return_code = 0;
4222
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004223 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004224 while (curproxy) {
4225 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004226
4227 /* servers are in backend only */
Amaury Denoyellee3c41922021-01-06 14:28:50 +01004228 if (!(curproxy->cap & PR_CAP_BE) || curproxy->disabled)
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004229 goto srv_init_addr_next;
4230
Willy Tarreau25e51522016-11-04 15:10:17 +01004231 for (srv = curproxy->srv; srv; srv = srv->next)
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004232 if (srv->hostname || srv->srvrq)
Willy Tarreau3d609a72017-09-06 14:22:45 +02004233 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004234
4235 srv_init_addr_next:
4236 curproxy = curproxy->next;
4237 }
4238
4239 return return_code;
4240}
4241
Willy Tarreau46b7f532018-08-21 11:54:26 +02004242/*
4243 * Must be called with the server lock held.
4244 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004245const char *update_server_fqdn(struct server *server, const char *fqdn, const char *updater, int dns_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004246{
4247
Willy Tarreau83061a82018-07-13 11:56:34 +02004248 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004249
4250 msg = get_trash_chunk();
4251 chunk_reset(msg);
4252
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004253 if (server->hostname && strcmp(fqdn, server->hostname) == 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004254 chunk_appendf(msg, "no need to change the FDQN");
4255 goto out;
4256 }
4257
4258 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
4259 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
4260 goto out;
4261 }
4262
4263 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
4264 server->proxy->id, server->id, server->hostname, fqdn);
4265
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004266 if (srv_set_fqdn(server, fqdn, dns_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004267 chunk_reset(msg);
4268 chunk_appendf(msg, "could not update %s/%s FQDN",
4269 server->proxy->id, server->id);
4270 goto out;
4271 }
4272
4273 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02004274 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004275
4276 out:
4277 if (updater)
4278 chunk_appendf(msg, " by '%s'", updater);
4279 chunk_appendf(msg, "\n");
4280
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004281 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004282}
4283
4284
Willy Tarreau21b069d2016-11-23 17:15:08 +01004285/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
4286 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004287 * 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 +01004288 * used for CLI commands requiring a server name.
4289 * Important: the <arg> is modified to remove the '/'.
4290 */
4291struct server *cli_find_server(struct appctx *appctx, char *arg)
4292{
4293 struct proxy *px;
4294 struct server *sv;
4295 char *line;
4296
4297 /* split "backend/server" and make <line> point to server */
4298 for (line = arg; *line; line++)
4299 if (*line == '/') {
4300 *line++ = '\0';
4301 break;
4302 }
4303
4304 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004305 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004306 return NULL;
4307 }
4308
4309 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004310 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004311 return NULL;
4312 }
4313
Willy Tarreauc3914d42020-09-24 08:39:22 +02004314 if (px->disabled) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004315 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004316 return NULL;
4317 }
4318
4319 return sv;
4320}
4321
William Lallemand222baf22016-11-19 02:00:33 +01004322
Willy Tarreau46b7f532018-08-21 11:54:26 +02004323/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004324static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01004325{
4326 struct server *sv;
4327 const char *warning;
4328
4329 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4330 return 1;
4331
4332 sv = cli_find_server(appctx, args[2]);
4333 if (!sv)
4334 return 1;
4335
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004336 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02004337
William Lallemand222baf22016-11-19 02:00:33 +01004338 if (strcmp(args[3], "weight") == 0) {
4339 warning = server_parse_weight_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004340 if (warning)
4341 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004342 }
4343 else if (strcmp(args[3], "state") == 0) {
4344 if (strcmp(args[4], "ready") == 0)
4345 srv_adm_set_ready(sv);
4346 else if (strcmp(args[4], "drain") == 0)
4347 srv_adm_set_drain(sv);
4348 else if (strcmp(args[4], "maint") == 0)
4349 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02004350 else
4351 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004352 }
4353 else if (strcmp(args[3], "health") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004354 if (sv->track)
4355 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004356 else if (strcmp(args[4], "up") == 0) {
4357 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004358 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004359 }
4360 else if (strcmp(args[4], "stopping") == 0) {
4361 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004362 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004363 }
4364 else if (strcmp(args[4], "down") == 0) {
4365 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004366 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004367 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004368 else
4369 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004370 }
4371 else if (strcmp(args[3], "agent") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004372 if (!(sv->agent.state & CHK_ST_ENABLED))
4373 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004374 else if (strcmp(args[4], "up") == 0) {
4375 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004376 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004377 }
4378 else if (strcmp(args[4], "down") == 0) {
4379 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004380 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004381 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004382 else
4383 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004384 }
Misiek2da082d2017-01-09 09:40:42 +01004385 else if (strcmp(args[3], "agent-addr") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004386 if (!(sv->agent.state & CHK_ST_ENABLED))
4387 cli_err(appctx, "agent checks are not enabled on this server.\n");
4388 else if (str2ip(args[4], &sv->agent.addr) == NULL)
4389 cli_err(appctx, "incorrect addr address given for agent.\n");
Misiek2da082d2017-01-09 09:40:42 +01004390 }
4391 else if (strcmp(args[3], "agent-send") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004392 if (!(sv->agent.state & CHK_ST_ENABLED))
4393 cli_err(appctx, "agent checks are not enabled on this server.\n");
4394 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02004395 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02004396 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01004397 }
4398 }
William Lallemand222baf22016-11-19 02:00:33 +01004399 else if (strcmp(args[3], "check-port") == 0) {
4400 int i = 0;
4401 if (strl2irc(args[4], strlen(args[4]), &i) != 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004402 cli_err(appctx, "'set server <srv> check-port' expects an integer as argument.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004403 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004404 }
4405 if ((i < 0) || (i > 65535)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004406 cli_err(appctx, "provided port is not valid.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004407 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004408 }
4409 /* prevent the update of port to 0 if MAPPORTS are in use */
4410 if ((sv->flags & SRV_F_MAPPORTS) && (i == 0)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004411 cli_err(appctx, "can't unset 'port' since MAPPORTS is in use.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004412 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004413 }
4414 sv->check.port = i;
Willy Tarreau9d008692019-08-09 11:21:01 +02004415 cli_msg(appctx, LOG_NOTICE, "health check port updated.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004416 }
4417 else if (strcmp(args[3], "addr") == 0) {
4418 char *addr = NULL;
4419 char *port = NULL;
4420 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004421 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004422 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004423 }
4424 else {
4425 addr = args[4];
4426 }
4427 if (strcmp(args[5], "port") == 0) {
4428 port = args[6];
4429 }
4430 warning = update_server_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02004431 if (warning)
4432 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004433 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
4434 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004435 else if (strcmp(args[3], "fqdn") == 0) {
4436 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004437 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004438 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004439 }
Baptiste Assmann13a92322019-06-07 09:40:55 +02004440 /* ensure runtime resolver will process this new fqdn */
4441 if (sv->flags & SRV_F_NO_RESOLUTION) {
4442 sv->flags &= ~SRV_F_NO_RESOLUTION;
4443 }
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004444 warning = update_server_fqdn(sv, args[4], "stats socket command", 0);
Willy Tarreau9d008692019-08-09 11:21:01 +02004445 if (warning)
4446 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004447 }
William Dauchyf6370442020-11-14 19:25:33 +01004448 else if (strcmp(args[3], "ssl") == 0) {
4449#ifdef USE_OPENSSL
4450 if (sv->ssl_ctx.ctx == NULL) {
4451 cli_err(appctx, "'set server <srv> ssl' cannot be set. "
4452 " default-server should define ssl settings\n");
4453 goto out_unlock;
4454 } else if (strcmp(args[4], "on") == 0) {
4455 ssl_sock_set_srv(sv, 1);
4456 } else if (strcmp(args[4], "off") == 0) {
4457 ssl_sock_set_srv(sv, 0);
4458 } else {
4459 cli_err(appctx, "'set server <srv> ssl' expects 'on' or 'off'.\n");
4460 goto out_unlock;
4461 }
4462 srv_cleanup_connections(sv);
4463 cli_msg(appctx, LOG_NOTICE, "server ssl setting updated.\n");
4464#else
4465 cli_msg(appctx, LOG_NOTICE, "server ssl setting not supported.\n");
4466#endif
4467 } else {
Willy Tarreau9d008692019-08-09 11:21:01 +02004468 cli_err(appctx,
4469 "'set server <srv>' only supports 'agent', 'health', 'state',"
William Dauchyf6370442020-11-14 19:25:33 +01004470 " 'weight', 'addr', 'fqdn', 'check-port' and 'ssl'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004471 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004472 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004473 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004474 return 1;
4475}
4476
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004477static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004478{
4479 struct stream_interface *si = appctx->owner;
4480 struct proxy *px;
4481 struct server *sv;
4482 char *line;
4483
4484
4485 /* split "backend/server" and make <line> point to server */
4486 for (line = args[2]; *line; line++)
4487 if (*line == '/') {
4488 *line++ = '\0';
4489 break;
4490 }
4491
Willy Tarreau9d008692019-08-09 11:21:01 +02004492 if (!*line)
4493 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004494
Willy Tarreau9d008692019-08-09 11:21:01 +02004495 if (!get_backend_server(args[2], line, &px, &sv))
4496 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004497
4498 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004499 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
4500 sv->iweight);
4501 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004502 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004503 return 0;
4504 }
William Lallemand6b160942016-11-22 12:34:35 +01004505 return 1;
4506}
4507
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004508/* Parse a "set weight" command.
4509 *
4510 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004511 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004512static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004513{
4514 struct server *sv;
4515 const char *warning;
4516
4517 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4518 return 1;
4519
4520 sv = cli_find_server(appctx, args[2]);
4521 if (!sv)
4522 return 1;
4523
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004524 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4525
William Lallemand6b160942016-11-22 12:34:35 +01004526 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004527 if (warning)
4528 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004529
4530 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4531
William Lallemand6b160942016-11-22 12:34:35 +01004532 return 1;
4533}
4534
Willy Tarreau46b7f532018-08-21 11:54:26 +02004535/* parse a "set maxconn server" command. It always returns 1.
4536 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004537 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004538 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004539static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01004540{
4541 struct server *sv;
4542 const char *warning;
4543
4544 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4545 return 1;
4546
4547 sv = cli_find_server(appctx, args[3]);
4548 if (!sv)
4549 return 1;
4550
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004551 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4552
Willy Tarreaub8026272016-11-23 11:26:56 +01004553 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004554 if (warning)
4555 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004556
4557 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4558
Willy Tarreaub8026272016-11-23 11:26:56 +01004559 return 1;
4560}
William Lallemand6b160942016-11-22 12:34:35 +01004561
Willy Tarreau46b7f532018-08-21 11:54:26 +02004562/* parse a "disable agent" command. It always returns 1.
4563 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004564 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004565 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004566static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004567{
4568 struct server *sv;
4569
4570 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4571 return 1;
4572
4573 sv = cli_find_server(appctx, args[2]);
4574 if (!sv)
4575 return 1;
4576
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004577 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004578 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004579 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004580 return 1;
4581}
4582
Willy Tarreau46b7f532018-08-21 11:54:26 +02004583/* parse a "disable health" command. It always returns 1.
4584 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004585 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004586 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004587static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004588{
4589 struct server *sv;
4590
4591 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4592 return 1;
4593
4594 sv = cli_find_server(appctx, args[2]);
4595 if (!sv)
4596 return 1;
4597
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004598 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004599 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004600 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004601 return 1;
4602}
4603
Willy Tarreau46b7f532018-08-21 11:54:26 +02004604/* parse a "disable server" command. It always returns 1.
4605 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004606 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004607 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004608static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004609{
4610 struct server *sv;
4611
4612 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4613 return 1;
4614
4615 sv = cli_find_server(appctx, args[2]);
4616 if (!sv)
4617 return 1;
4618
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004619 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004620 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004621 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004622 return 1;
4623}
4624
Willy Tarreau46b7f532018-08-21 11:54:26 +02004625/* parse a "enable agent" command. It always returns 1.
4626 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004627 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004628 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004629static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004630{
4631 struct server *sv;
4632
4633 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4634 return 1;
4635
4636 sv = cli_find_server(appctx, args[2]);
4637 if (!sv)
4638 return 1;
4639
Willy Tarreau9d008692019-08-09 11:21:01 +02004640 if (!(sv->agent.state & CHK_ST_CONFIGURED))
4641 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004642
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004643 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004644 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004645 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004646 return 1;
4647}
4648
Willy Tarreau46b7f532018-08-21 11:54:26 +02004649/* parse a "enable health" command. It always returns 1.
4650 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004651 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004652 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004653static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004654{
4655 struct server *sv;
4656
4657 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4658 return 1;
4659
4660 sv = cli_find_server(appctx, args[2]);
4661 if (!sv)
4662 return 1;
4663
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004664 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004665 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004666 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004667 return 1;
4668}
4669
Willy Tarreau46b7f532018-08-21 11:54:26 +02004670/* parse a "enable server" command. It always returns 1.
4671 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004672 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004673 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004674static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004675{
4676 struct server *sv;
4677
4678 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4679 return 1;
4680
4681 sv = cli_find_server(appctx, args[2]);
4682 if (!sv)
4683 return 1;
4684
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004685 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004686 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004687 if (!(sv->flags & SRV_F_COOKIESET)
4688 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4689 sv->cookie)
4690 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004691 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004692 return 1;
4693}
4694
William Lallemand222baf22016-11-19 02:00:33 +01004695/* register cli keywords */
4696static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004697 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004698 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004699 { { "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 +01004700 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004701 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004702 { { "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 +01004703 { { "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 +01004704 { { "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 +01004705 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4706 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4707
William Lallemand222baf22016-11-19 02:00:33 +01004708 {{},}
4709}};
4710
Willy Tarreau0108d902018-11-25 19:14:37 +01004711INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004712
Emeric Brun64cc49c2017-10-03 14:46:45 +02004713/*
4714 * This function applies server's status changes, it is
4715 * is designed to be called asynchronously.
4716 *
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004717 * Must be called with the server lock held. This may also be called at init
4718 * time as the result of parsing the state file, in which case no lock will be
4719 * held, and the server's warmup task can be null.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004720 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004721static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004722{
4723 struct check *check = &s->check;
4724 int xferred;
4725 struct proxy *px = s->proxy;
4726 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4727 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4728 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004729 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004730
Emeric Brun64cc49c2017-10-03 14:46:45 +02004731 /* If currently main is not set we try to apply pending state changes */
4732 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4733 int next_admin;
4734
4735 /* Backup next admin */
4736 next_admin = s->next_admin;
4737
4738 /* restore current admin state */
4739 s->next_admin = s->cur_admin;
4740
4741 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4742 s->last_change = now.tv_sec;
4743 if (s->proxy->lbprm.set_server_status_down)
4744 s->proxy->lbprm.set_server_status_down(s);
4745
4746 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4747 srv_shutdown_streams(s, SF_ERR_DOWN);
4748
4749 /* we might have streams queued on this server and waiting for
4750 * a connection. Those which are redispatchable will be queued
4751 * to another server or to the proxy itself.
4752 */
4753 xferred = pendconn_redistribute(s);
4754
4755 tmptrash = alloc_trash_chunk();
4756 if (tmptrash) {
4757 chunk_printf(tmptrash,
4758 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4759 s->proxy->id, s->id);
4760
Emeric Brun5a133512017-10-19 14:42:30 +02004761 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004762 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004763
4764 /* we don't send an alert if the server was previously paused */
4765 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004766 send_log(s->proxy, log_level, "%s.\n",
4767 tmptrash->area);
4768 send_email_alert(s, log_level, "%s",
4769 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004770 free_trash_chunk(tmptrash);
4771 tmptrash = NULL;
4772 }
4773 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4774 set_backend_down(s->proxy);
4775
4776 s->counters.down_trans++;
4777 }
4778 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4779 s->last_change = now.tv_sec;
4780 if (s->proxy->lbprm.set_server_status_down)
4781 s->proxy->lbprm.set_server_status_down(s);
4782
4783 /* we might have streams queued on this server and waiting for
4784 * a connection. Those which are redispatchable will be queued
4785 * to another server or to the proxy itself.
4786 */
4787 xferred = pendconn_redistribute(s);
4788
4789 tmptrash = alloc_trash_chunk();
4790 if (tmptrash) {
4791 chunk_printf(tmptrash,
4792 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4793 s->proxy->id, s->id);
4794
Emeric Brun5a133512017-10-19 14:42:30 +02004795 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004796
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004797 ha_warning("%s.\n", tmptrash->area);
4798 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4799 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004800 free_trash_chunk(tmptrash);
4801 tmptrash = NULL;
4802 }
4803
4804 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4805 set_backend_down(s->proxy);
4806 }
4807 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4808 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4809 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4810 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4811 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4812 s->proxy->last_change = now.tv_sec;
4813 }
4814
Amaury Denoyellefe2bf092020-10-29 15:59:04 +01004815 if (s->cur_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
Emeric Brun64cc49c2017-10-03 14:46:45 +02004816 s->down_time += now.tv_sec - s->last_change;
4817
4818 s->last_change = now.tv_sec;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004819 if (s->next_state == SRV_ST_STARTING && s->warmup)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004820 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4821
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004822 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004823 /* now propagate the status change to any LB algorithms */
4824 if (px->lbprm.update_server_eweight)
4825 px->lbprm.update_server_eweight(s);
4826 else if (srv_willbe_usable(s)) {
4827 if (px->lbprm.set_server_status_up)
4828 px->lbprm.set_server_status_up(s);
4829 }
4830 else {
4831 if (px->lbprm.set_server_status_down)
4832 px->lbprm.set_server_status_down(s);
4833 }
4834
4835 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4836 * and it's not a backup server and its effective weight is > 0,
4837 * then it can accept new connections, so we shut down all streams
4838 * on all backup servers.
4839 */
4840 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4841 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4842 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4843
4844 /* check if we can handle some connections queued at the proxy. We
4845 * will take as many as we can handle.
4846 */
4847 xferred = pendconn_grab_from_px(s);
4848
4849 tmptrash = alloc_trash_chunk();
4850 if (tmptrash) {
4851 chunk_printf(tmptrash,
4852 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4853 s->proxy->id, s->id);
4854
Emeric Brun5a133512017-10-19 14:42:30 +02004855 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004856 ha_warning("%s.\n", tmptrash->area);
4857 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4858 tmptrash->area);
4859 send_email_alert(s, LOG_NOTICE, "%s",
4860 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004861 free_trash_chunk(tmptrash);
4862 tmptrash = NULL;
4863 }
4864
4865 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4866 set_backend_down(s->proxy);
4867 }
4868 else if (s->cur_eweight != s->next_eweight) {
4869 /* now propagate the status change to any LB algorithms */
4870 if (px->lbprm.update_server_eweight)
4871 px->lbprm.update_server_eweight(s);
4872 else if (srv_willbe_usable(s)) {
4873 if (px->lbprm.set_server_status_up)
4874 px->lbprm.set_server_status_up(s);
4875 }
4876 else {
4877 if (px->lbprm.set_server_status_down)
4878 px->lbprm.set_server_status_down(s);
4879 }
4880
4881 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4882 set_backend_down(s->proxy);
4883 }
4884
4885 s->next_admin = next_admin;
4886 }
4887
Emeric Brun5a133512017-10-19 14:42:30 +02004888 /* reset operational state change */
4889 *s->op_st_chg.reason = 0;
4890 s->op_st_chg.status = s->op_st_chg.code = -1;
4891 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004892
4893 /* Now we try to apply pending admin changes */
4894
4895 /* Maintenance must also disable health checks */
4896 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4897 if (s->check.state & CHK_ST_ENABLED) {
4898 s->check.state |= CHK_ST_PAUSED;
4899 check->health = 0;
4900 }
4901
4902 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004903 tmptrash = alloc_trash_chunk();
4904 if (tmptrash) {
4905 chunk_printf(tmptrash,
4906 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4907 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4908 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004909
Olivier Houchard796a2b32017-10-24 17:42:47 +02004910 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004911
Olivier Houchard796a2b32017-10-24 17:42:47 +02004912 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004913 ha_warning("%s.\n", tmptrash->area);
4914 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4915 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004916 }
4917 free_trash_chunk(tmptrash);
4918 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004919 }
Emeric Brun8f298292017-12-06 16:47:17 +01004920 /* commit new admin status */
4921
4922 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004923 }
4924 else { /* server was still running */
4925 check->health = 0; /* failure */
4926 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004927
4928 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004929 if (s->proxy->lbprm.set_server_status_down)
4930 s->proxy->lbprm.set_server_status_down(s);
4931
Emeric Brun64cc49c2017-10-03 14:46:45 +02004932 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4933 srv_shutdown_streams(s, SF_ERR_DOWN);
4934
William Dauchy6318d332020-05-02 21:52:36 +02004935 /* force connection cleanup on the given server */
4936 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004937 /* we might have streams queued on this server and waiting for
4938 * a connection. Those which are redispatchable will be queued
4939 * to another server or to the proxy itself.
4940 */
4941 xferred = pendconn_redistribute(s);
4942
4943 tmptrash = alloc_trash_chunk();
4944 if (tmptrash) {
4945 chunk_printf(tmptrash,
4946 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
4947 s->flags & SRV_F_BACKUP ? "Backup " : "",
4948 s->proxy->id, s->id,
4949 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4950
4951 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
4952
4953 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004954 ha_warning("%s.\n", tmptrash->area);
4955 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
4956 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004957 }
4958 free_trash_chunk(tmptrash);
4959 tmptrash = NULL;
4960 }
4961 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4962 set_backend_down(s->proxy);
4963
4964 s->counters.down_trans++;
4965 }
4966 }
4967 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
4968 /* OK here we're leaving maintenance, we have many things to check,
4969 * because the server might possibly be coming back up depending on
4970 * its state. In practice, leaving maintenance means that we should
4971 * immediately turn to UP (more or less the slowstart) under the
4972 * following conditions :
4973 * - server is neither checked nor tracked
4974 * - server tracks another server which is not checked
4975 * - server tracks another server which is already up
4976 * Which sums up as something simpler :
4977 * "either the tracking server is up or the server's checks are disabled
4978 * or up". Otherwise we only re-enable health checks. There's a special
4979 * case associated to the stopping state which can be inherited. Note
4980 * that the server might still be in drain mode, which is naturally dealt
4981 * with by the lower level functions.
4982 */
4983
4984 if (s->check.state & CHK_ST_ENABLED) {
4985 s->check.state &= ~CHK_ST_PAUSED;
4986 check->health = check->rise; /* start OK but check immediately */
4987 }
4988
4989 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
4990 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
4991 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
4992 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
4993 s->next_state = SRV_ST_STOPPING;
4994 }
4995 else {
4996 s->next_state = SRV_ST_STARTING;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004997 if (s->slowstart > 0) {
4998 if (s->warmup)
4999 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
5000 }
Emeric Brun64cc49c2017-10-03 14:46:45 +02005001 else
5002 s->next_state = SRV_ST_RUNNING;
5003 }
5004
5005 }
5006
5007 tmptrash = alloc_trash_chunk();
5008 if (tmptrash) {
5009 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5010 chunk_printf(tmptrash,
5011 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
5012 s->flags & SRV_F_BACKUP ? "Backup " : "",
5013 s->proxy->id, s->id,
5014 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5015 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5016 }
5017 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5018 chunk_printf(tmptrash,
5019 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
5020 s->flags & SRV_F_BACKUP ? "Backup " : "",
5021 s->proxy->id, s->id, s->hostname,
5022 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5023 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5024 }
5025 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5026 chunk_printf(tmptrash,
5027 "%sServer %s/%s is %s/%s (leaving maintenance)",
5028 s->flags & SRV_F_BACKUP ? "Backup " : "",
5029 s->proxy->id, s->id,
5030 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5031 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5032 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005033 ha_warning("%s.\n", tmptrash->area);
5034 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5035 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005036 free_trash_chunk(tmptrash);
5037 tmptrash = NULL;
5038 }
5039
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005040 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005041 /* now propagate the status change to any LB algorithms */
5042 if (px->lbprm.update_server_eweight)
5043 px->lbprm.update_server_eweight(s);
5044 else if (srv_willbe_usable(s)) {
5045 if (px->lbprm.set_server_status_up)
5046 px->lbprm.set_server_status_up(s);
5047 }
5048 else {
5049 if (px->lbprm.set_server_status_down)
5050 px->lbprm.set_server_status_down(s);
5051 }
5052
5053 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5054 set_backend_down(s->proxy);
5055
Willy Tarreau6a78e612018-08-07 10:14:53 +02005056 /* If the server is set with "on-marked-up shutdown-backup-sessions",
5057 * and it's not a backup server and its effective weight is > 0,
5058 * then it can accept new connections, so we shut down all streams
5059 * on all backup servers.
5060 */
5061 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
5062 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
5063 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
5064
5065 /* check if we can handle some connections queued at the proxy. We
5066 * will take as many as we can handle.
5067 */
5068 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005069 }
5070 else if (s->next_admin & SRV_ADMF_MAINT) {
5071 /* remaining in maintenance mode, let's inform precisely about the
5072 * situation.
5073 */
5074 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5075 tmptrash = alloc_trash_chunk();
5076 if (tmptrash) {
5077 chunk_printf(tmptrash,
5078 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
5079 s->flags & SRV_F_BACKUP ? "Backup " : "",
5080 s->proxy->id, s->id);
5081
5082 if (s->track) /* normally it's mandatory here */
5083 chunk_appendf(tmptrash, " via %s/%s",
5084 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005085 ha_warning("%s.\n", tmptrash->area);
5086 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5087 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005088 free_trash_chunk(tmptrash);
5089 tmptrash = NULL;
5090 }
5091 }
5092 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5093 tmptrash = alloc_trash_chunk();
5094 if (tmptrash) {
5095 chunk_printf(tmptrash,
5096 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
5097 s->flags & SRV_F_BACKUP ? "Backup " : "",
5098 s->proxy->id, s->id, s->hostname);
5099
5100 if (s->track) /* normally it's mandatory here */
5101 chunk_appendf(tmptrash, " via %s/%s",
5102 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005103 ha_warning("%s.\n", tmptrash->area);
5104 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5105 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005106 free_trash_chunk(tmptrash);
5107 tmptrash = NULL;
5108 }
5109 }
5110 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5111 tmptrash = alloc_trash_chunk();
5112 if (tmptrash) {
5113 chunk_printf(tmptrash,
5114 "%sServer %s/%s remains in forced maintenance",
5115 s->flags & SRV_F_BACKUP ? "Backup " : "",
5116 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005117 ha_warning("%s.\n", tmptrash->area);
5118 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5119 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005120 free_trash_chunk(tmptrash);
5121 tmptrash = NULL;
5122 }
5123 }
5124 /* don't report anything when leaving drain mode and remaining in maintenance */
5125
5126 s->cur_admin = s->next_admin;
5127 }
5128
5129 if (!(s->next_admin & SRV_ADMF_MAINT)) {
5130 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
5131 /* drain state is applied only if not yet in maint */
5132
5133 s->last_change = now.tv_sec;
5134 if (px->lbprm.set_server_status_down)
5135 px->lbprm.set_server_status_down(s);
5136
5137 /* we might have streams queued on this server and waiting for
5138 * a connection. Those which are redispatchable will be queued
5139 * to another server or to the proxy itself.
5140 */
5141 xferred = pendconn_redistribute(s);
5142
5143 tmptrash = alloc_trash_chunk();
5144 if (tmptrash) {
5145 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
5146 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5147 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5148
5149 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
5150
5151 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005152 ha_warning("%s.\n", tmptrash->area);
5153 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5154 tmptrash->area);
5155 send_email_alert(s, LOG_NOTICE, "%s",
5156 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005157 }
5158 free_trash_chunk(tmptrash);
5159 tmptrash = NULL;
5160 }
5161
5162 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5163 set_backend_down(s->proxy);
5164 }
5165 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
5166 /* OK completely leaving drain mode */
5167 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
5168 if (s->proxy->last_change < now.tv_sec) // ignore negative times
5169 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
5170 s->proxy->last_change = now.tv_sec;
5171 }
5172
5173 if (s->last_change < now.tv_sec) // ignore negative times
5174 s->down_time += now.tv_sec - s->last_change;
5175 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005176 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005177
5178 tmptrash = alloc_trash_chunk();
5179 if (tmptrash) {
5180 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5181 chunk_printf(tmptrash,
5182 "%sServer %s/%s is %s (leaving forced drain)",
5183 s->flags & SRV_F_BACKUP ? "Backup " : "",
5184 s->proxy->id, s->id,
5185 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5186 }
5187 else {
5188 chunk_printf(tmptrash,
5189 "%sServer %s/%s is %s (leaving drain)",
5190 s->flags & SRV_F_BACKUP ? "Backup " : "",
5191 s->proxy->id, s->id,
5192 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5193 if (s->track) /* normally it's mandatory here */
5194 chunk_appendf(tmptrash, " via %s/%s",
5195 s->track->proxy->id, s->track->id);
5196 }
5197
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005198 ha_warning("%s.\n", tmptrash->area);
5199 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5200 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005201 free_trash_chunk(tmptrash);
5202 tmptrash = NULL;
5203 }
5204
5205 /* now propagate the status change to any LB algorithms */
5206 if (px->lbprm.update_server_eweight)
5207 px->lbprm.update_server_eweight(s);
5208 else if (srv_willbe_usable(s)) {
5209 if (px->lbprm.set_server_status_up)
5210 px->lbprm.set_server_status_up(s);
5211 }
5212 else {
5213 if (px->lbprm.set_server_status_down)
5214 px->lbprm.set_server_status_down(s);
5215 }
5216 }
5217 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
5218 /* remaining in drain mode after removing one of its flags */
5219
5220 tmptrash = alloc_trash_chunk();
5221 if (tmptrash) {
5222 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5223 chunk_printf(tmptrash,
5224 "%sServer %s/%s is leaving forced drain but remains in drain mode",
5225 s->flags & SRV_F_BACKUP ? "Backup " : "",
5226 s->proxy->id, s->id);
5227
5228 if (s->track) /* normally it's mandatory here */
5229 chunk_appendf(tmptrash, " via %s/%s",
5230 s->track->proxy->id, s->track->id);
5231 }
5232 else {
5233 chunk_printf(tmptrash,
5234 "%sServer %s/%s remains in forced drain mode",
5235 s->flags & SRV_F_BACKUP ? "Backup " : "",
5236 s->proxy->id, s->id);
5237 }
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 /* commit new admin status */
5246
5247 s->cur_admin = s->next_admin;
5248 }
5249 }
5250
5251 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02005252 *s->adm_st_chg_cause = 0;
5253}
Emeric Brun64cc49c2017-10-03 14:46:45 +02005254
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005255struct task *srv_cleanup_toremove_connections(struct task *task, void *context, unsigned short state)
5256{
5257 struct connection *conn;
5258
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005259 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005260 struct connection *, list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02005261 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005262 }
5263
5264 return task;
5265}
5266
Olivier Houchardff1d0922020-06-29 20:15:59 +02005267/* Move toremove_nb connections from idle_list to toremove_list, -1 means
5268 * moving them all.
5269 * Returns the number of connections moved.
5270 */
5271static int srv_migrate_conns_to_remove(struct mt_list *idle_list, struct mt_list *toremove_list, int toremove_nb)
5272{
5273 struct mt_list *elt1, elt2;
5274 struct connection *conn;
5275 int i = 0;
5276
5277 mt_list_for_each_entry_safe(conn, idle_list, list, elt1, elt2) {
5278 if (toremove_nb != -1 && i >= toremove_nb)
5279 break;
5280 MT_LIST_DEL_SAFE_NOINIT(elt1);
Willy Tarreaude4db172020-07-10 08:10:29 +02005281 MT_LIST_ADDQ(toremove_list, &conn->list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005282 i++;
5283 }
5284 return i;
5285}
William Dauchy6318d332020-05-02 21:52:36 +02005286/* cleanup connections for a given server
5287 * might be useful when going on forced maintenance or live changing ip/port
5288 */
William Dauchy707ad322020-05-04 13:52:40 +02005289static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02005290{
William Dauchy6318d332020-05-02 21:52:36 +02005291 int did_remove;
5292 int i;
William Dauchy6318d332020-05-02 21:52:36 +02005293
Amaury Denoyelle10d5c312021-01-06 14:28:51 +01005294 /* nothing to do if pool-max-conn is null */
5295 if (!srv->max_idle_conns)
5296 return;
5297
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005298 /* check all threads starting with ours */
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005299 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02005300 did_remove = 0;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005301 if (srv_migrate_conns_to_remove(&srv->idle_conns[i], &idle_conns[i].toremove_conns, -1) > 0)
William Dauchy6318d332020-05-02 21:52:36 +02005302 did_remove = 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005303 if (srv_migrate_conns_to_remove(&srv->safe_conns[i], &idle_conns[i].toremove_conns, -1) > 0)
5304 did_remove = 1;
William Dauchy6318d332020-05-02 21:52:36 +02005305 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005306 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005307
5308 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5309 break;
William Dauchy6318d332020-05-02 21:52:36 +02005310 }
William Dauchy6318d332020-05-02 21:52:36 +02005311}
5312
Willy Tarreau980855b2019-02-07 14:59:29 +01005313struct task *srv_cleanup_idle_connections(struct task *task, void *context, unsigned short state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005314{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005315 struct server *srv;
5316 struct eb32_node *eb;
5317 int i;
5318 unsigned int next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005319
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005320 next_wakeup = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005321 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
5322 while (1) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005323 int exceed_conns;
5324 int to_kill;
5325 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005326
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005327 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
5328 if (!eb) {
5329 /* we might have reached the end of the tree, typically because
5330 * <now_ms> is in the first half and we're first scanning the last
5331 * half. Let's loop back to the beginning of the tree now.
5332 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005333
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005334 eb = eb32_first(&idle_conn_srv);
5335 if (likely(!eb))
5336 break;
5337 }
5338 if (tick_is_lt(now_ms, eb->key)) {
5339 /* timer not expired yet, revisit it later */
5340 next_wakeup = eb->key;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005341 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005342 }
5343 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005344
5345 /* Calculate how many idle connections we want to kill :
5346 * we want to remove half the difference between the total
5347 * of established connections (used or idle) and the max
5348 * number of used connections.
5349 */
5350 curr_idle = srv->curr_idle_conns;
5351 if (curr_idle == 0)
5352 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005353 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005354 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005355
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005356 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns) / 2;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005357 if (srv->est_need_conns < srv->max_used_conns)
5358 srv->est_need_conns = srv->max_used_conns;
5359
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005360 srv->max_used_conns = srv->curr_used_conns;
5361
Willy Tarreau18ed7892020-07-02 19:05:30 +02005362 if (exceed_conns <= 0)
5363 goto remove;
5364
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005365 /* check all threads starting with ours */
5366 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005367 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005368 int j;
5369 int did_remove = 0;
5370
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005371 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
5372 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005373
5374 j = srv_migrate_conns_to_remove(&srv->idle_conns[i], &idle_conns[i].toremove_conns, max_conn);
5375 if (j > 0)
5376 did_remove = 1;
5377 if (max_conn - j > 0 &&
5378 srv_migrate_conns_to_remove(&srv->safe_conns[i], &idle_conns[i].toremove_conns, max_conn - j) > 0)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005379 did_remove = 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005380
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005381 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005382 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005383
5384 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5385 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005386 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005387remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005388 eb32_delete(&srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005389
5390 if (srv->curr_idle_conns) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005391 /* There are still more idle connections, add the
5392 * server back in the tree.
5393 */
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005394 srv->idle_node.key = tick_add(srv->pool_purge_delay, now_ms);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005395 eb32_insert(&idle_conn_srv, &srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005396 next_wakeup = tick_first(next_wakeup, srv->idle_node.key);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005397 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005398 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005399 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5400
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005401 task->expire = next_wakeup;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005402 return task;
5403}
Olivier Houchard88698d92019-04-16 19:07:22 +02005404
Willy Tarreau76cc6992020-07-01 18:49:24 +02005405/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
5406static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
5407 struct proxy *defpx, const char *file, int line,
5408 char **err)
5409{
5410 if (too_many_args(1, args, err, NULL))
5411 return -1;
5412
5413 if (strcmp(args[1], "on") == 0)
5414 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
5415 else if (strcmp(args[1], "off") == 0)
5416 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
5417 else {
5418 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
5419 return -1;
5420 }
5421 return 0;
5422}
5423
Olivier Houchard88698d92019-04-16 19:07:22 +02005424/* config parser for global "tune.pool-{low,high}-fd-ratio" */
5425static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
5426 struct proxy *defpx, const char *file, int line,
5427 char **err)
5428{
5429 int arg = -1;
5430
5431 if (too_many_args(1, args, err, NULL))
5432 return -1;
5433
5434 if (*(args[1]) != 0)
5435 arg = atoi(args[1]);
5436
5437 if (arg < 0 || arg > 100) {
5438 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
5439 return -1;
5440 }
5441
5442 if (args[0][10] == 'h')
5443 global.tune.pool_high_ratio = arg;
5444 else
5445 global.tune.pool_low_ratio = arg;
5446 return 0;
5447}
5448
5449/* config keyword parsers */
5450static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02005451 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02005452 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
5453 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
5454 { 0, NULL, NULL }
5455}};
5456
5457INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
5458
Baptiste Assmanna68ca962015-04-14 01:15:08 +02005459/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02005460 * Local variables:
5461 * c-indent-level: 8
5462 * c-basic-offset: 8
5463 * End:
5464 */