blob: 07e82ada5dd6cc82ef3b3be1056f0351c63aa2fe [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Server management functions.
3 *
Willy Tarreau21faa912012-10-10 08:27:36 +02004 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01005 * Copyright 2007-2008 Krzysztof Piotr Oledzki <ole@ans.pl>
Willy Tarreaubaaee002006-06-26 02:48:02 +02006 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
Willy Tarreau0a4b0ab2020-06-11 11:22:44 +020014#include <sys/types.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020015#include <netinet/tcp.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020016#include <ctype.h>
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020017#include <errno.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020018
Willy Tarreau6be78492020-06-05 00:00:29 +020019#include <import/xxhash.h>
20
Willy Tarreaub2551052020-06-09 09:07:15 +020021#include <haproxy/api.h>
Willy Tarreau3f0f82e2020-06-04 19:42:41 +020022#include <haproxy/applet-t.h>
Willy Tarreau49801602020-06-04 22:50:02 +020023#include <haproxy/backend.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020024#include <haproxy/cfgparse.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020025#include <haproxy/check.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020026#include <haproxy/cli.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020027#include <haproxy/connection.h>
Willy Tarreau3afc4c42020-06-03 18:23:19 +020028#include <haproxy/dict-t.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020029#include <haproxy/errors.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020030#include <haproxy/global.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020031#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020032#include <haproxy/mailers.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020033#include <haproxy/namespace.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020034#include <haproxy/port_range.h>
35#include <haproxy/protocol.h>
Willy Tarreaua55c4542020-06-04 22:59:39 +020036#include <haproxy/queue.h>
Emeric Brunc9437992021-02-12 19:42:55 +010037#include <haproxy/resolvers.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020038#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020039#include <haproxy/server.h>
William Dauchyf6370442020-11-14 19:25:33 +010040#include <haproxy/ssl_sock.h>
Amaury Denoyellef99f77a2021-03-08 17:13:32 +010041#include <haproxy/stats.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020042#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020043#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020044#include <haproxy/task.h>
Willy Tarreau51cd5952020-06-05 12:25:38 +020045#include <haproxy/tcpcheck.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020046#include <haproxy/time.h>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020047
Baptiste Assmannda29fe22019-06-13 13:24:29 +020048
Willy Tarreau3ff577e2018-08-02 11:48:52 +020049static void srv_update_status(struct server *s);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010050static int srv_apply_lastaddr(struct server *srv, int *err_code);
William Dauchy6318d332020-05-02 21:52:36 +020051static void srv_cleanup_connections(struct server *srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +020052
Amaury Denoyelle587b71e2021-03-10 16:36:02 +010053/* extra keywords used as value for other arguments. They are used as
54 * suggestions for mistyped words.
Willy Tarreau49c2b452021-03-12 09:58:04 +010055 */
Amaury Denoyelle587b71e2021-03-10 16:36:02 +010056static const char *extra_kw_list[] = {
57 "ipv4", "ipv6", "legacy", "octet-count",
Amaury Denoyelle3b89c112021-03-12 16:04:00 +010058 "fail-check", "sudden-death", "mark-down",
Willy Tarreau49c2b452021-03-12 09:58:04 +010059 NULL /* must be last */
60};
61
Willy Tarreau21faa912012-10-10 08:27:36 +020062/* List head of all known server keywords */
63static struct srv_kw_list srv_keywords = {
64 .list = LIST_HEAD_INIT(srv_keywords.list)
65};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020066
Willy Tarreauaf613e82020-06-05 08:40:51 +020067__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010068struct eb_root idle_conn_srv = EB_ROOT;
Willy Tarreau14015b82021-04-10 17:33:15 +020069struct task *idle_conn_task __read_mostly = NULL;
Willy Tarreau198e92a2021-03-05 10:23:32 +010070struct list servers_list = LIST_HEAD_INIT(servers_list);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010071
Frédéric Lécaille7da71292019-05-20 09:47:07 +020072/* The server names dictionary */
Thayne McCombs92149f92020-11-20 01:28:26 -070073struct dict server_key_dict = {
74 .name = "server keys",
Frédéric Lécaille7da71292019-05-20 09:47:07 +020075 .values = EB_ROOT_UNIQUE,
76};
77
Simon Hormana3608442013-11-01 16:46:15 +090078int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020079{
Amaury Denoyellee6ba7912020-10-29 15:59:05 +010080 if ((s->cur_state != SRV_ST_STOPPED) || s->last_change >= now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020081 return s->down_time;
82
83 return now.tv_sec - s->last_change + s->down_time;
84}
Willy Tarreaubaaee002006-06-26 02:48:02 +020085
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050086int srv_lastsession(const struct server *s)
87{
88 if (s->counters.last_sess)
89 return now.tv_sec - s->counters.last_sess;
90
91 return -1;
92}
93
Simon Horman4a741432013-02-23 15:35:38 +090094int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020095{
Simon Horman4a741432013-02-23 15:35:38 +090096 const struct server *s = check->server;
97
Willy Tarreauff5ae352013-12-11 20:36:34 +010098 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090099 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100100
Emeric Brun52a91d32017-08-31 14:41:55 +0200101 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +0900102 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100103
Simon Horman4a741432013-02-23 15:35:38 +0900104 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100105}
106
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100107/*
108 * Check that we did not get a hash collision.
Willy Tarreau595e7672020-10-20 17:30:08 +0200109 * Unlikely, but it can happen. The server's proxy must be at least
110 * read-locked.
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100111 */
112static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +0100113{
114 struct proxy *p = s->proxy;
115 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100116
117 for (tmpserv = p->srv; tmpserv != NULL;
118 tmpserv = tmpserv->next) {
119 if (tmpserv == s)
120 continue;
121 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
122 continue;
123 if (tmpserv->cookie &&
124 strcmp(tmpserv->cookie, s->cookie) == 0) {
125 ha_warning("We generated two equal cookies for two different servers.\n"
126 "Please change the secret key for '%s'.\n",
127 s->proxy->id);
128 }
129 }
130
131}
132
Willy Tarreau46b7f532018-08-21 11:54:26 +0200133/*
Willy Tarreau595e7672020-10-20 17:30:08 +0200134 * Must be called with the server lock held, and will read-lock the proxy.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200135 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100136void srv_set_dyncookie(struct server *s)
137{
138 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100139 char *tmpbuf;
140 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100141 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100142 size_t buffer_len;
143 int addr_len;
144 int port;
145
Willy Tarreau595e7672020-10-20 17:30:08 +0200146 HA_RWLOCK_RDLOCK(PROXY_LOCK, &p->lock);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200147
Olivier Houchard4e694042017-03-14 20:01:29 +0100148 if ((s->flags & SRV_F_COOKIESET) ||
149 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
150 s->proxy->dyncookie_key == NULL)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200151 goto out;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100152 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100153
154 if (s->addr.ss_family != AF_INET &&
155 s->addr.ss_family != AF_INET6)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200156 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100157 /*
158 * Buffer to calculate the cookie value.
159 * The buffer contains the secret key + the server IP address
160 * + the TCP port.
161 */
162 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
163 /*
164 * The TCP port should use only 2 bytes, but is stored in
165 * an unsigned int in struct server, so let's use 4, to be
166 * on the safe side.
167 */
168 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200169 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100170 memcpy(tmpbuf, p->dyncookie_key, key_len);
171 memcpy(&(tmpbuf[key_len]),
172 s->addr.ss_family == AF_INET ?
173 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
174 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
175 addr_len);
176 /*
177 * Make sure it's the same across all the load balancers,
178 * no matter their endianness.
179 */
180 port = htonl(s->svc_port);
181 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
182 hash_value = XXH64(tmpbuf, buffer_len, 0);
183 memprintf(&s->cookie, "%016llx", hash_value);
184 if (!s->cookie)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200185 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100186 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100187
188 /* Don't bother checking if the dyncookie is duplicated if
189 * the server is marked as "disabled", maybe it doesn't have
190 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100191 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100192 if (!(s->next_admin & SRV_ADMF_FMAINT))
193 srv_check_for_dup_dyncookie(s);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200194 out:
Willy Tarreau595e7672020-10-20 17:30:08 +0200195 HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &p->lock);
Olivier Houchard4e694042017-03-14 20:01:29 +0100196}
197
Willy Tarreau21faa912012-10-10 08:27:36 +0200198/*
Thayne McCombs92149f92020-11-20 01:28:26 -0700199 * Must be called with the server lock held, and will write-lock the proxy.
200 */
201static void srv_set_addr_desc(struct server *s)
202{
203 struct proxy *p = s->proxy;
204 char *key;
205
206 key = sa2str(&s->addr, s->svc_port, s->flags & SRV_F_MAPPORTS);
207
208 if (s->addr_node.key) {
Thayne McCombs24da7e12021-01-05 23:10:09 -0700209 if (key && strcmp(key, s->addr_node.key) == 0) {
Thayne McCombs92149f92020-11-20 01:28:26 -0700210 free(key);
211 return;
212 }
213
214 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
215 ebpt_delete(&s->addr_node);
216 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
217
218 free(s->addr_node.key);
219 }
220
221 s->addr_node.key = key;
222
Thayne McCombs24da7e12021-01-05 23:10:09 -0700223 if (s->addr_node.key) {
224 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
225 ebis_insert(&p->used_server_addr, &s->addr_node);
226 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
227 }
Thayne McCombs92149f92020-11-20 01:28:26 -0700228}
229
230/*
Willy Tarreau21faa912012-10-10 08:27:36 +0200231 * Registers the server keyword list <kwl> as a list of valid keywords for next
232 * parsing sessions.
233 */
234void srv_register_keywords(struct srv_kw_list *kwl)
235{
Willy Tarreau2b718102021-04-21 07:32:39 +0200236 LIST_APPEND(&srv_keywords.list, &kwl->list);
Willy Tarreau21faa912012-10-10 08:27:36 +0200237}
238
239/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
240 * keyword is found with a NULL ->parse() function, then an attempt is made to
241 * find one with a valid ->parse() function. This way it is possible to declare
242 * platform-dependant, known keywords as NULL, then only declare them as valid
243 * if some options are met. Note that if the requested keyword contains an
244 * opening parenthesis, everything from this point is ignored.
245 */
246struct srv_kw *srv_find_kw(const char *kw)
247{
248 int index;
249 const char *kwend;
250 struct srv_kw_list *kwl;
251 struct srv_kw *ret = NULL;
252
253 kwend = strchr(kw, '(');
254 if (!kwend)
255 kwend = kw + strlen(kw);
256
257 list_for_each_entry(kwl, &srv_keywords.list, list) {
258 for (index = 0; kwl->kw[index].kw != NULL; index++) {
259 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
260 kwl->kw[index].kw[kwend-kw] == 0) {
261 if (kwl->kw[index].parse)
262 return &kwl->kw[index]; /* found it !*/
263 else
264 ret = &kwl->kw[index]; /* may be OK */
265 }
266 }
267 }
268 return ret;
269}
270
271/* Dumps all registered "server" keywords to the <out> string pointer. The
272 * unsupported keywords are only dumped if their supported form was not
273 * found.
274 */
275void srv_dump_kws(char **out)
276{
277 struct srv_kw_list *kwl;
278 int index;
279
Christopher Faulet784063e2020-05-18 12:14:18 +0200280 if (!out)
281 return;
282
Willy Tarreau21faa912012-10-10 08:27:36 +0200283 *out = NULL;
284 list_for_each_entry(kwl, &srv_keywords.list, list) {
285 for (index = 0; kwl->kw[index].kw != NULL; index++) {
286 if (kwl->kw[index].parse ||
287 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
288 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
289 kwl->scope,
290 kwl->kw[index].kw,
291 kwl->kw[index].skip ? " <arg>" : "",
292 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
293 kwl->kw[index].parse ? "" : " (not supported)");
294 }
295 }
296 }
Willy Tarreau49c2b452021-03-12 09:58:04 +0100297}
298
299/* Try to find in srv_keyword the word that looks closest to <word> by counting
300 * transitions between letters, digits and other characters. Will return the
301 * best matching word if found, otherwise NULL. An optional array of extra
302 * words to compare may be passed in <extra>, but it must then be terminated
303 * by a NULL entry. If unused it may be NULL.
304 */
305static const char *srv_find_best_kw(const char *word)
306{
307 uint8_t word_sig[1024];
308 uint8_t list_sig[1024];
309 const struct srv_kw_list *kwl;
310 const char *best_ptr = NULL;
311 int dist, best_dist = INT_MAX;
312 const char **extra;
313 int index;
314
315 make_word_fingerprint(word_sig, word);
316 list_for_each_entry(kwl, &srv_keywords.list, list) {
317 for (index = 0; kwl->kw[index].kw != NULL; index++) {
318 make_word_fingerprint(list_sig, kwl->kw[index].kw);
319 dist = word_fingerprint_distance(word_sig, list_sig);
320 if (dist < best_dist) {
321 best_dist = dist;
322 best_ptr = kwl->kw[index].kw;
323 }
324 }
325 }
326
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100327 for (extra = extra_kw_list; *extra; extra++) {
Willy Tarreau49c2b452021-03-12 09:58:04 +0100328 make_word_fingerprint(list_sig, *extra);
329 dist = word_fingerprint_distance(word_sig, list_sig);
330 if (dist < best_dist) {
331 best_dist = dist;
332 best_ptr = *extra;
333 }
Willy Tarreau49c2b452021-03-12 09:58:04 +0100334 }
335
336 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
337 best_ptr = NULL;
338
339 return best_ptr;
Willy Tarreau21faa912012-10-10 08:27:36 +0200340}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100341
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100342/* Parse the "backup" server keyword */
343static int srv_parse_backup(char **args, int *cur_arg,
344 struct proxy *curproxy, struct server *newsrv, char **err)
345{
346 newsrv->flags |= SRV_F_BACKUP;
347 return 0;
348}
349
Alexander Liu2a54bb72019-05-22 19:44:48 +0800350
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100351/* Parse the "cookie" server keyword */
352static int srv_parse_cookie(char **args, int *cur_arg,
353 struct proxy *curproxy, struct server *newsrv, char **err)
354{
355 char *arg;
356
357 arg = args[*cur_arg + 1];
358 if (!*arg) {
359 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
360 return ERR_ALERT | ERR_FATAL;
361 }
362
363 free(newsrv->cookie);
364 newsrv->cookie = strdup(arg);
365 newsrv->cklen = strlen(arg);
366 newsrv->flags |= SRV_F_COOKIESET;
367 return 0;
368}
369
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100370/* Parse the "disabled" server keyword */
371static int srv_parse_disabled(char **args, int *cur_arg,
372 struct proxy *curproxy, struct server *newsrv, char **err)
373{
Emeric Brun52a91d32017-08-31 14:41:55 +0200374 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
375 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100376 newsrv->check.state |= CHK_ST_PAUSED;
377 newsrv->check.health = 0;
378 return 0;
379}
380
381/* Parse the "enabled" server keyword */
382static int srv_parse_enabled(char **args, int *cur_arg,
383 struct proxy *curproxy, struct server *newsrv, char **err)
384{
Emeric Brun52a91d32017-08-31 14:41:55 +0200385 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
386 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100387 newsrv->check.state &= ~CHK_ST_PAUSED;
388 newsrv->check.health = newsrv->check.rise;
389 return 0;
390}
391
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100392/* Parse the "error-limit" server keyword */
393static int srv_parse_error_limit(char **args, int *cur_arg,
394 struct proxy *curproxy, struct server *newsrv, char **err)
395{
396 if (!*args[*cur_arg + 1]) {
397 memprintf(err, "'%s' expects an integer argument.",
398 args[*cur_arg]);
399 return ERR_ALERT | ERR_FATAL;
400 }
401
402 newsrv->consecutive_errors_limit = atoi(args[*cur_arg + 1]);
403
404 if (newsrv->consecutive_errors_limit <= 0) {
405 memprintf(err, "%s has to be > 0.",
406 args[*cur_arg]);
407 return ERR_ALERT | ERR_FATAL;
408 }
409
410 return 0;
411}
412
413/* Parse the "init-addr" server keyword */
414static int srv_parse_init_addr(char **args, int *cur_arg,
415 struct proxy *curproxy, struct server *newsrv, char **err)
416{
417 char *p, *end;
418 int done;
419 struct sockaddr_storage sa;
420
421 newsrv->init_addr_methods = 0;
422 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
423
424 for (p = args[*cur_arg + 1]; *p; p = end) {
425 /* cut on next comma */
426 for (end = p; *end && *end != ','; end++);
427 if (*end)
428 *(end++) = 0;
429
430 memset(&sa, 0, sizeof(sa));
431 if (strcmp(p, "libc") == 0) {
432 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
433 }
434 else if (strcmp(p, "last") == 0) {
435 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
436 }
437 else if (strcmp(p, "none") == 0) {
438 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
439 }
440 else if (str2ip2(p, &sa, 0)) {
441 if (is_addr(&newsrv->init_addr)) {
442 memprintf(err, "'%s' : initial address already specified, cannot add '%s'.",
443 args[*cur_arg], p);
444 return ERR_ALERT | ERR_FATAL;
445 }
446 newsrv->init_addr = sa;
447 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
448 }
449 else {
450 memprintf(err, "'%s' : unknown init-addr method '%s', supported methods are 'libc', 'last', 'none'.",
451 args[*cur_arg], p);
452 return ERR_ALERT | ERR_FATAL;
453 }
454 if (!done) {
455 memprintf(err, "'%s' : too many init-addr methods when trying to add '%s'",
456 args[*cur_arg], p);
457 return ERR_ALERT | ERR_FATAL;
458 }
459 }
460
461 return 0;
462}
463
464/* Parse the "log-proto" server keyword */
465static int srv_parse_log_proto(char **args, int *cur_arg,
466 struct proxy *curproxy, struct server *newsrv, char **err)
467{
468 if (strcmp(args[*cur_arg + 1], "legacy") == 0)
469 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
470 else if (strcmp(args[*cur_arg + 1], "octet-count") == 0)
471 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
472 else {
473 memprintf(err, "'%s' expects one of 'legacy' or 'octet-count' but got '%s'",
474 args[*cur_arg], args[*cur_arg + 1]);
475 return ERR_ALERT | ERR_FATAL;
476 }
477
478 return 0;
479}
480
481/* Parse the "maxconn" server keyword */
482static int srv_parse_maxconn(char **args, int *cur_arg,
483 struct proxy *curproxy, struct server *newsrv, char **err)
484{
485 newsrv->maxconn = atol(args[*cur_arg + 1]);
486 return 0;
487}
488
489/* Parse the "maxqueue" server keyword */
490static int srv_parse_maxqueue(char **args, int *cur_arg,
491 struct proxy *curproxy, struct server *newsrv, char **err)
492{
493 newsrv->maxqueue = atol(args[*cur_arg + 1]);
494 return 0;
495}
496
497/* Parse the "minconn" server keyword */
498static int srv_parse_minconn(char **args, int *cur_arg,
499 struct proxy *curproxy, struct server *newsrv, char **err)
500{
501 newsrv->minconn = atol(args[*cur_arg + 1]);
502 return 0;
503}
504
Willy Tarreau9c538e02019-01-23 10:21:49 +0100505static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
506{
507 char *arg;
508
509 arg = args[*cur_arg + 1];
510 if (!*arg) {
511 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
512 return ERR_ALERT | ERR_FATAL;
513 }
514 newsrv->max_reuse = atoi(arg);
515
516 return 0;
517}
518
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100519static 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 +0100520{
521 const char *res;
522 char *arg;
523 unsigned int time;
524
525 arg = args[*cur_arg + 1];
526 if (!*arg) {
527 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
528 return ERR_ALERT | ERR_FATAL;
529 }
530 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200531 if (res == PARSE_TIME_OVER) {
532 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
533 args[*cur_arg+1], args[*cur_arg]);
534 return ERR_ALERT | ERR_FATAL;
535 }
536 else if (res == PARSE_TIME_UNDER) {
537 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
538 args[*cur_arg+1], args[*cur_arg]);
539 return ERR_ALERT | ERR_FATAL;
540 }
541 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100542 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
543 *res, args[*cur_arg]);
544 return ERR_ALERT | ERR_FATAL;
545 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100546 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100547
548 return 0;
549}
550
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200551static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
552{
553 char *arg;
554
555 arg = args[*cur_arg + 1];
556 if (!*arg) {
557 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
558 return ERR_ALERT | ERR_FATAL;
559 }
560
561 newsrv->low_idle_conns = atoi(arg);
562 return 0;
563}
564
Olivier Houchard006e3102018-12-10 18:30:32 +0100565static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
566{
567 char *arg;
568
569 arg = args[*cur_arg + 1];
570 if (!*arg) {
571 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
572 return ERR_ALERT | ERR_FATAL;
573 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100574
Olivier Houchard006e3102018-12-10 18:30:32 +0100575 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100576 if ((int)newsrv->max_idle_conns < -1) {
577 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
578 return ERR_ALERT | ERR_FATAL;
579 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100580
581 return 0;
582}
583
Willy Tarreaudff55432012-10-10 17:51:05 +0200584/* parse the "id" server keyword */
585static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
586{
587 struct eb32_node *node;
588
589 if (!*args[*cur_arg + 1]) {
590 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
591 return ERR_ALERT | ERR_FATAL;
592 }
593
594 newsrv->puid = atol(args[*cur_arg + 1]);
595 newsrv->conf.id.key = newsrv->puid;
596
597 if (newsrv->puid <= 0) {
598 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
599 return ERR_ALERT | ERR_FATAL;
600 }
601
602 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
603 if (node) {
604 struct server *target = container_of(node, struct server, conf.id);
605 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
606 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
607 target->id);
608 return ERR_ALERT | ERR_FATAL;
609 }
610
611 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200612 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200613 return 0;
614}
615
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100616/* Parse the "namespace" server keyword */
617static int srv_parse_namespace(char **args, int *cur_arg,
618 struct proxy *curproxy, struct server *newsrv, char **err)
619{
Willy Tarreaue5733232019-05-22 19:24:06 +0200620#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100621 char *arg;
622
623 arg = args[*cur_arg + 1];
624 if (!*arg) {
625 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
626 return ERR_ALERT | ERR_FATAL;
627 }
628
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100629 if (strcmp(arg, "*") == 0) {
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100630 /* Use the namespace associated with the connection (if present). */
631 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
632 return 0;
633 }
634
635 /*
636 * As this parser may be called several times for the same 'default-server'
637 * object, or for a new 'server' instance deriving from a 'default-server'
638 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
639 */
640 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
641
642 newsrv->netns = netns_store_lookup(arg, strlen(arg));
643 if (!newsrv->netns)
644 newsrv->netns = netns_store_insert(arg);
645
646 if (!newsrv->netns) {
647 memprintf(err, "Cannot open namespace '%s'", arg);
648 return ERR_ALERT | ERR_FATAL;
649 }
650
651 return 0;
652#else
653 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
654 return ERR_ALERT | ERR_FATAL;
655#endif
656}
657
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100658/* Parse the "no-backup" server keyword */
659static int srv_parse_no_backup(char **args, int *cur_arg,
660 struct proxy *curproxy, struct server *newsrv, char **err)
661{
662 newsrv->flags &= ~SRV_F_BACKUP;
663 return 0;
664}
665
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100666
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100667/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200668static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100669{
670 srv->pp_opts &= ~flags;
671 return 0;
672}
673
674/* Parse the "no-send-proxy" server keyword */
675static int srv_parse_no_send_proxy(char **args, int *cur_arg,
676 struct proxy *curproxy, struct server *newsrv, char **err)
677{
678 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
679}
680
681/* Parse the "no-send-proxy-v2" server keyword */
682static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
683 struct proxy *curproxy, struct server *newsrv, char **err)
684{
685 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
686}
687
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200688/* Parse the "no-tfo" server keyword */
689static int srv_parse_no_tfo(char **args, int *cur_arg,
690 struct proxy *curproxy, struct server *newsrv, char **err)
691{
692 newsrv->flags &= ~SRV_F_FASTOPEN;
693 return 0;
694}
695
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100696/* Parse the "non-stick" server keyword */
697static int srv_parse_non_stick(char **args, int *cur_arg,
698 struct proxy *curproxy, struct server *newsrv, char **err)
699{
700 newsrv->flags |= SRV_F_NON_STICK;
701 return 0;
702}
703
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100704/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200705static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100706{
707 srv->pp_opts |= flags;
708 return 0;
709}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200710/* parse the "proto" server keyword */
711static int srv_parse_proto(char **args, int *cur_arg,
712 struct proxy *px, struct server *newsrv, char **err)
713{
714 struct ist proto;
715
716 if (!*args[*cur_arg + 1]) {
717 memprintf(err, "'%s' : missing value", args[*cur_arg]);
718 return ERR_ALERT | ERR_FATAL;
719 }
Tim Duesterhusdcf753a2021-03-04 17:31:47 +0100720 proto = ist(args[*cur_arg + 1]);
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200721 newsrv->mux_proto = get_mux_proto(proto);
722 if (!newsrv->mux_proto) {
723 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
724 return ERR_ALERT | ERR_FATAL;
725 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200726 return 0;
727}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100728
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100729/* parse the "proxy-v2-options" */
730static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
731 struct proxy *px, struct server *newsrv, char **err)
732{
733 char *p, *n;
734 for (p = args[*cur_arg+1]; p; p = n) {
735 n = strchr(p, ',');
736 if (n)
737 *n++ = '\0';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100738 if (strcmp(p, "ssl") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100739 newsrv->pp_opts |= SRV_PP_V2_SSL;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100740 } else if (strcmp(p, "cert-cn") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100741 newsrv->pp_opts |= SRV_PP_V2_SSL;
742 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100743 } else if (strcmp(p, "cert-key") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100744 newsrv->pp_opts |= SRV_PP_V2_SSL;
745 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100746 } else if (strcmp(p, "cert-sig") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100747 newsrv->pp_opts |= SRV_PP_V2_SSL;
748 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100749 } else if (strcmp(p, "ssl-cipher") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100750 newsrv->pp_opts |= SRV_PP_V2_SSL;
751 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100752 } else if (strcmp(p, "authority") == 0) {
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100753 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100754 } else if (strcmp(p, "crc32c") == 0) {
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100755 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100756 } else if (strcmp(p, "unique-id") == 0) {
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100757 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100758 } else
759 goto fail;
760 }
761 return 0;
762 fail:
763 if (err)
764 memprintf(err, "'%s' : proxy v2 option not implemented", p);
765 return ERR_ALERT | ERR_FATAL;
766}
767
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100768/* Parse the "observe" server keyword */
769static int srv_parse_observe(char **args, int *cur_arg,
770 struct proxy *curproxy, struct server *newsrv, char **err)
771{
772 char *arg;
773
774 arg = args[*cur_arg + 1];
775 if (!*arg) {
776 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
777 return ERR_ALERT | ERR_FATAL;
778 }
779
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100780 if (strcmp(arg, "none") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100781 newsrv->observe = HANA_OBS_NONE;
782 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100783 else if (strcmp(arg, "layer4") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100784 newsrv->observe = HANA_OBS_LAYER4;
785 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100786 else if (strcmp(arg, "layer7") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100787 if (curproxy->mode != PR_MODE_HTTP) {
788 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
789 return ERR_ALERT;
790 }
791 newsrv->observe = HANA_OBS_LAYER7;
792 }
793 else {
794 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
795 "but got '%s'\n", args[*cur_arg], arg);
796 return ERR_ALERT | ERR_FATAL;
797 }
798
799 return 0;
800}
801
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100802/* Parse the "on-error" server keyword */
803static int srv_parse_on_error(char **args, int *cur_arg,
804 struct proxy *curproxy, struct server *newsrv, char **err)
805{
806 if (strcmp(args[*cur_arg + 1], "fastinter") == 0)
807 newsrv->onerror = HANA_ONERR_FASTINTER;
808 else if (strcmp(args[*cur_arg + 1], "fail-check") == 0)
809 newsrv->onerror = HANA_ONERR_FAILCHK;
810 else if (strcmp(args[*cur_arg + 1], "sudden-death") == 0)
811 newsrv->onerror = HANA_ONERR_SUDDTH;
812 else if (strcmp(args[*cur_arg + 1], "mark-down") == 0)
813 newsrv->onerror = HANA_ONERR_MARKDWN;
814 else {
815 memprintf(err, "'%s' expects one of 'fastinter', "
816 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'",
817 args[*cur_arg], args[*cur_arg + 1]);
818 return ERR_ALERT | ERR_FATAL;
819 }
820
821 return 0;
822}
823
824/* Parse the "on-marked-down" server keyword */
825static int srv_parse_on_marked_down(char **args, int *cur_arg,
826 struct proxy *curproxy, struct server *newsrv, char **err)
827{
828 if (strcmp(args[*cur_arg + 1], "shutdown-sessions") == 0)
829 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
830 else {
831 memprintf(err, "'%s' expects 'shutdown-sessions' but got '%s'",
832 args[*cur_arg], args[*cur_arg + 1]);
833 return ERR_ALERT | ERR_FATAL;
834 }
835
836 return 0;
837}
838
839/* Parse the "on-marked-up" server keyword */
840static int srv_parse_on_marked_up(char **args, int *cur_arg,
841 struct proxy *curproxy, struct server *newsrv, char **err)
842{
843 if (strcmp(args[*cur_arg + 1], "shutdown-backup-sessions") == 0)
844 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
845 else {
846 memprintf(err, "'%s' expects 'shutdown-backup-sessions' but got '%s'",
847 args[*cur_arg], args[*cur_arg + 1]);
848 return ERR_ALERT | ERR_FATAL;
849 }
850
851 return 0;
852}
853
Frédéric Lécaille16186232017-03-14 16:42:49 +0100854/* Parse the "redir" server keyword */
855static int srv_parse_redir(char **args, int *cur_arg,
856 struct proxy *curproxy, struct server *newsrv, char **err)
857{
858 char *arg;
859
860 arg = args[*cur_arg + 1];
861 if (!*arg) {
862 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
863 return ERR_ALERT | ERR_FATAL;
864 }
865
866 free(newsrv->rdr_pfx);
867 newsrv->rdr_pfx = strdup(arg);
868 newsrv->rdr_len = strlen(arg);
869
870 return 0;
871}
872
Amaury Denoyelle587b71e2021-03-10 16:36:02 +0100873/* Parse the "resolvers" server keyword */
874static int srv_parse_resolvers(char **args, int *cur_arg,
875 struct proxy *curproxy, struct server *newsrv, char **err)
876{
877 free(newsrv->resolvers_id);
878 newsrv->resolvers_id = strdup(args[*cur_arg + 1]);
879 return 0;
880}
881
882/* Parse the "resolve-net" server keyword */
883static int srv_parse_resolve_net(char **args, int *cur_arg,
884 struct proxy *curproxy, struct server *newsrv, char **err)
885{
886 char *p, *e;
887 unsigned char mask;
888 struct resolv_options *opt;
889
890 if (!args[*cur_arg + 1] || args[*cur_arg + 1][0] == '\0') {
891 memprintf(err, "'%s' expects a list of networks.",
892 args[*cur_arg]);
893 return ERR_ALERT | ERR_FATAL;
894 }
895
896 opt = &newsrv->resolv_opts;
897
898 /* Split arguments by comma, and convert it from ipv4 or ipv6
899 * string network in in_addr or in6_addr.
900 */
901 p = args[*cur_arg + 1];
902 e = p;
903 while (*p != '\0') {
904 /* If no room available, return error. */
905 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
906 memprintf(err, "'%s' exceed %d networks.",
907 args[*cur_arg], SRV_MAX_PREF_NET);
908 return ERR_ALERT | ERR_FATAL;
909 }
910 /* look for end or comma. */
911 while (*e != ',' && *e != '\0')
912 e++;
913 if (*e == ',') {
914 *e = '\0';
915 e++;
916 }
917 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
918 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
919 /* Try to convert input string from ipv4 or ipv6 network. */
920 opt->pref_net[opt->pref_net_nb].family = AF_INET;
921 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
922 &mask)) {
923 /* Try to convert input string from ipv6 network. */
924 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
925 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
926 } else {
927 /* All network conversions fail, return error. */
928 memprintf(err, "'%s' invalid network '%s'.",
929 args[*cur_arg], p);
930 return ERR_ALERT | ERR_FATAL;
931 }
932 opt->pref_net_nb++;
933 p = e;
934 }
935
936 return 0;
937}
938
939/* Parse the "resolve-opts" server keyword */
940static int srv_parse_resolve_opts(char **args, int *cur_arg,
941 struct proxy *curproxy, struct server *newsrv, char **err)
942{
943 char *p, *end;
944
945 for (p = args[*cur_arg + 1]; *p; p = end) {
946 /* cut on next comma */
947 for (end = p; *end && *end != ','; end++);
948 if (*end)
949 *(end++) = 0;
950
951 if (strcmp(p, "allow-dup-ip") == 0) {
952 newsrv->resolv_opts.accept_duplicate_ip = 1;
953 }
954 else if (strcmp(p, "ignore-weight") == 0) {
955 newsrv->resolv_opts.ignore_weight = 1;
956 }
957 else if (strcmp(p, "prevent-dup-ip") == 0) {
958 newsrv->resolv_opts.accept_duplicate_ip = 0;
959 }
960 else {
961 memprintf(err, "'%s' : unknown resolve-opts option '%s', supported methods are 'allow-dup-ip', 'ignore-weight', and 'prevent-dup-ip'.",
962 args[*cur_arg], p);
963 return ERR_ALERT | ERR_FATAL;
964 }
965 }
966
967 return 0;
968}
969
970/* Parse the "resolve-prefer" server keyword */
971static int srv_parse_resolve_prefer(char **args, int *cur_arg,
972 struct proxy *curproxy, struct server *newsrv, char **err)
973{
974 if (strcmp(args[*cur_arg + 1], "ipv4") == 0)
975 newsrv->resolv_opts.family_prio = AF_INET;
976 else if (strcmp(args[*cur_arg + 1], "ipv6") == 0)
977 newsrv->resolv_opts.family_prio = AF_INET6;
978 else {
979 memprintf(err, "'%s' expects either ipv4 or ipv6 as argument.",
980 args[*cur_arg]);
981 return ERR_ALERT | ERR_FATAL;
982 }
983
984 return 0;
985}
986
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100987/* Parse the "send-proxy" server keyword */
988static int srv_parse_send_proxy(char **args, int *cur_arg,
989 struct proxy *curproxy, struct server *newsrv, char **err)
990{
991 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
992}
993
994/* Parse the "send-proxy-v2" server keyword */
995static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
996 struct proxy *curproxy, struct server *newsrv, char **err)
997{
998 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
999}
1000
Amaury Denoyelle587b71e2021-03-10 16:36:02 +01001001/* Parse the "slowstart" server keyword */
1002static int srv_parse_slowstart(char **args, int *cur_arg,
1003 struct proxy *curproxy, struct server *newsrv, char **err)
1004{
1005 /* slowstart is stored in seconds */
1006 unsigned int val;
1007 const char *time_err = parse_time_err(args[*cur_arg + 1], &val, TIME_UNIT_MS);
1008
1009 if (time_err == PARSE_TIME_OVER) {
1010 memprintf(err, "overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
1011 args[*cur_arg+1], args[*cur_arg], newsrv->id);
1012 return ERR_ALERT | ERR_FATAL;
1013 }
1014 else if (time_err == PARSE_TIME_UNDER) {
1015 memprintf(err, "underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
1016 args[*cur_arg+1], args[*cur_arg], newsrv->id);
1017 return ERR_ALERT | ERR_FATAL;
1018 }
1019 else if (time_err) {
1020 memprintf(err, "unexpected character '%c' in 'slowstart' argument of server %s.",
1021 *time_err, newsrv->id);
1022 return ERR_ALERT | ERR_FATAL;
1023 }
1024 newsrv->slowstart = (val + 999) / 1000;
1025
1026 return 0;
1027}
Frédéric Lécailledba97072017-03-17 15:33:50 +01001028
1029/* Parse the "source" server keyword */
1030static int srv_parse_source(char **args, int *cur_arg,
1031 struct proxy *curproxy, struct server *newsrv, char **err)
1032{
1033 char *errmsg;
1034 int port_low, port_high;
1035 struct sockaddr_storage *sk;
Frédéric Lécailledba97072017-03-17 15:33:50 +01001036
1037 errmsg = NULL;
1038
1039 if (!*args[*cur_arg + 1]) {
1040 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
1041 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
1042 goto err;
1043 }
1044
1045 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001046 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
1047 &errmsg, NULL, NULL,
1048 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 +01001049 if (!sk) {
1050 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
1051 goto err;
1052 }
1053
Frédéric Lécailledba97072017-03-17 15:33:50 +01001054 newsrv->conn_src.opts |= CO_SRC_BIND;
1055 newsrv->conn_src.source_addr = *sk;
1056
1057 if (port_low != port_high) {
1058 int i;
1059
Frédéric Lécailledba97072017-03-17 15:33:50 +01001060 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
1061 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
1062 newsrv->conn_src.sport_range->ports[i] = port_low + i;
1063 }
1064
1065 *cur_arg += 2;
1066 while (*(args[*cur_arg])) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001067 if (strcmp(args[*cur_arg], "usesrc") == 0) { /* address to use outside */
Frédéric Lécailledba97072017-03-17 15:33:50 +01001068#if defined(CONFIG_HAP_TRANSPARENT)
1069 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001070 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
1071 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +01001072 goto err;
1073 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001074 if (strcmp(args[*cur_arg + 1], "client") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +01001075 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1076 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
1077 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001078 else if (strcmp(args[*cur_arg + 1], "clientip") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +01001079 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1080 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
1081 }
1082 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
1083 char *name, *end;
1084
1085 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +01001086 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001087 name++;
1088
1089 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +01001090 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +01001091 end++;
1092
1093 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1094 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
1095 free(newsrv->conn_src.bind_hdr_name);
1096 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
1097 newsrv->conn_src.bind_hdr_len = end - name;
1098 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
1099 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
1100 newsrv->conn_src.bind_hdr_occ = -1;
1101
1102 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +01001103 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001104 end++;
1105 if (*end == ',') {
1106 end++;
1107 name = end;
1108 if (*end == '-')
1109 end++;
Willy Tarreau90807112020-02-25 08:16:33 +01001110 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +01001111 end++;
1112 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
1113 }
1114
1115 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001116 ha_alert("usesrc hdr_ip(name,num) does not support negative"
1117 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001118 goto err;
1119 }
1120 }
1121 else {
1122 struct sockaddr_storage *sk;
1123 int port1, port2;
1124
1125 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001126 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, NULL, NULL,
1127 &errmsg, NULL, NULL,
1128 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001129 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001130 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001131 goto err;
1132 }
1133
Frédéric Lécailledba97072017-03-17 15:33:50 +01001134 newsrv->conn_src.tproxy_addr = *sk;
1135 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
1136 }
1137 global.last_checks |= LSTCHK_NETADM;
1138 *cur_arg += 2;
1139 continue;
1140#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001141 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 +01001142 goto err;
1143#endif /* defined(CONFIG_HAP_TRANSPARENT) */
1144 } /* "usesrc" */
1145
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001146 if (strcmp(args[*cur_arg], "interface") == 0) { /* specifically bind to this interface */
Frédéric Lécailledba97072017-03-17 15:33:50 +01001147#ifdef SO_BINDTODEVICE
1148 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001149 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001150 goto err;
1151 }
1152 free(newsrv->conn_src.iface_name);
1153 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
1154 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
1155 global.last_checks |= LSTCHK_NETADM;
1156#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001157 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +01001158 goto err;
1159#endif
1160 *cur_arg += 2;
1161 continue;
1162 }
1163 /* this keyword in not an option of "source" */
1164 break;
1165 } /* while */
1166
1167 return 0;
1168
1169 err:
1170 free(errmsg);
1171 return ERR_ALERT | ERR_FATAL;
1172}
1173
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001174/* Parse the "stick" server keyword */
1175static int srv_parse_stick(char **args, int *cur_arg,
1176 struct proxy *curproxy, struct server *newsrv, char **err)
1177{
1178 newsrv->flags &= ~SRV_F_NON_STICK;
1179 return 0;
1180}
1181
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001182/* Parse the "track" server keyword */
1183static int srv_parse_track(char **args, int *cur_arg,
1184 struct proxy *curproxy, struct server *newsrv, char **err)
1185{
1186 char *arg;
1187
1188 arg = args[*cur_arg + 1];
1189 if (!*arg) {
1190 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
1191 return ERR_ALERT | ERR_FATAL;
1192 }
1193
1194 free(newsrv->trackit);
1195 newsrv->trackit = strdup(arg);
1196
1197 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001198}
1199
1200/* Parse the "socks4" server keyword */
1201static int srv_parse_socks4(char **args, int *cur_arg,
1202 struct proxy *curproxy, struct server *newsrv, char **err)
1203{
1204 char *errmsg;
1205 int port_low, port_high;
1206 struct sockaddr_storage *sk;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001207
1208 errmsg = NULL;
1209
1210 if (!*args[*cur_arg + 1]) {
1211 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
1212 goto err;
1213 }
1214
1215 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001216 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
1217 &errmsg, NULL, NULL,
1218 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_CONNECT);
Alexander Liu2a54bb72019-05-22 19:44:48 +08001219 if (!sk) {
1220 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
1221 goto err;
1222 }
1223
Alexander Liu2a54bb72019-05-22 19:44:48 +08001224 newsrv->flags |= SRV_F_SOCKS4_PROXY;
1225 newsrv->socks4_addr = *sk;
1226
Alexander Liu2a54bb72019-05-22 19:44:48 +08001227 return 0;
1228
1229 err:
1230 free(errmsg);
1231 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001232}
1233
Frédéric Lécailledba97072017-03-17 15:33:50 +01001234
Willy Tarreau034c88c2017-01-23 23:36:45 +01001235/* parse the "tfo" server keyword */
1236static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1237{
1238 newsrv->flags |= SRV_F_FASTOPEN;
1239 return 0;
1240}
1241
Amaury Denoyelle587b71e2021-03-10 16:36:02 +01001242/* parse the "usesrc" server keyword */
1243static int srv_parse_usesrc(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1244{
1245 memprintf(err, "'%s' only allowed after a '%s' statement.",
1246 "usesrc", "source");
1247 return ERR_ALERT | ERR_FATAL;
1248}
1249
1250/* parse the "weight" server keyword */
1251static int srv_parse_weight(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
1252{
1253 int w;
1254
1255 w = atol(args[*cur_arg + 1]);
1256 if (w < 0 || w > SRV_UWGHT_MAX) {
1257 memprintf(err, "weight of server %s is not within 0 and %d (%d).",
1258 newsrv->id, SRV_UWGHT_MAX, w);
1259 return ERR_ALERT | ERR_FATAL;
1260 }
1261 newsrv->uweight = newsrv->iweight = w;
1262
1263 return 0;
1264}
1265
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001266/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +02001267 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001268 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001269 *
1270 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001271 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001272void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001273{
Willy Tarreau751153e2021-02-17 13:33:24 +01001274 struct stream *stream;
1275 struct mt_list *elt1, elt2;
Willy Tarreaud4e78d82021-03-04 10:47:54 +01001276 int thr;
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001277
Willy Tarreaud4e78d82021-03-04 10:47:54 +01001278 for (thr = 0; thr < global.nbthread; thr++)
1279 mt_list_for_each_entry_safe(stream, &srv->per_thr[thr].streams, by_srv, elt1, elt2)
1280 if (stream->srv_conn == srv)
1281 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001282}
1283
1284/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +02001285 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001286 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001287 *
1288 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001289 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001290void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001291{
1292 struct server *srv;
1293
1294 for (srv = px->srv; srv != NULL; srv = srv->next)
1295 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +02001296 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +02001297}
1298
Willy Tarreaubda92272014-05-20 21:55:30 +02001299/* Appends some information to a message string related to a server going UP or
1300 * DOWN. If both <forced> and <reason> are null and the server tracks another
1301 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +02001302 * If <check> is non-null, an entire string describing the check result will be
1303 * appended after a comma and a space (eg: to report some information from the
1304 * check that changed the state). In the other case, the string will be built
1305 * using the check results stored into the struct server if present.
1306 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +02001307 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001308 *
1309 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001310 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001311void srv_append_status(struct buffer *msg, struct server *s,
1312 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001313{
Emeric Brun5a133512017-10-19 14:42:30 +02001314 short status = s->op_st_chg.status;
1315 short code = s->op_st_chg.code;
1316 long duration = s->op_st_chg.duration;
1317 char *desc = s->op_st_chg.reason;
1318
1319 if (check) {
1320 status = check->status;
1321 code = check->code;
1322 duration = check->duration;
1323 desc = check->desc;
1324 }
1325
1326 if (status != -1) {
1327 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
1328
1329 if (status >= HCHK_STATUS_L57DATA)
1330 chunk_appendf(msg, ", code: %d", code);
1331
1332 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001333 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +02001334
1335 chunk_appendf(msg, ", info: \"");
1336
1337 chunk_initlen(&src, desc, 0, strlen(desc));
1338 chunk_asciiencode(msg, &src, '"');
1339
1340 chunk_appendf(msg, "\"");
1341 }
1342
1343 if (duration >= 0)
1344 chunk_appendf(msg, ", check duration: %ldms", duration);
1345 }
1346 else if (desc && *desc) {
1347 chunk_appendf(msg, ", %s", desc);
1348 }
1349 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +02001350 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +02001351 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001352
1353 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +02001354 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001355 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
1356 " %d sessions active, %d requeued, %d remaining in queue",
1357 s->proxy->srv_act, s->proxy->srv_bck,
1358 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
1359 s->cur_sess, xferred, s->nbpend);
1360 else
1361 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
1362 " %d sessions requeued, %d total in queue",
1363 s->proxy->srv_act, s->proxy->srv_bck,
1364 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
1365 xferred, s->nbpend);
1366 }
1367}
1368
Emeric Brun5a133512017-10-19 14:42:30 +02001369/* Marks server <s> down, regardless of its checks' statuses. The server is
1370 * registered in a list to postpone the counting of the remaining servers on
1371 * the proxy and transfers queued streams whenever possible to other servers at
1372 * a sync point. Maintenance servers are ignored. It stores the <reason> if
1373 * non-null as the reason for going down or the available data from the check
1374 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001375 *
1376 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001377 */
Emeric Brun5a133512017-10-19 14:42:30 +02001378void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001379{
1380 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001381
Emeric Brun64cc49c2017-10-03 14:46:45 +02001382 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001383 return;
1384
Emeric Brun52a91d32017-08-31 14:41:55 +02001385 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001386 *s->op_st_chg.reason = 0;
1387 s->op_st_chg.status = -1;
1388 if (reason) {
1389 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1390 }
1391 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001392 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001393 s->op_st_chg.code = check->code;
1394 s->op_st_chg.status = check->status;
1395 s->op_st_chg.duration = check->duration;
1396 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001397
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001398 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001399 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001400
Emeric Brun9f0b4582017-10-23 14:39:51 +02001401 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001402 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001403 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001404 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001405 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001406}
1407
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001408/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001409 * in maintenance. The server is registered in a list to postpone the counting
1410 * of the remaining servers on the proxy and tries to grab requests from the
1411 * proxy at a sync point. Maintenance servers are ignored. It stores the
1412 * <reason> if non-null as the reason for going down or the available data
1413 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001414 *
1415 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001416 */
Emeric Brun5a133512017-10-19 14:42:30 +02001417void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001418{
1419 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001420
Emeric Brun64cc49c2017-10-03 14:46:45 +02001421 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001422 return;
1423
Emeric Brun52a91d32017-08-31 14:41:55 +02001424 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001425 return;
1426
Emeric Brun52a91d32017-08-31 14:41:55 +02001427 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001428 *s->op_st_chg.reason = 0;
1429 s->op_st_chg.status = -1;
1430 if (reason) {
1431 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1432 }
1433 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001434 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001435 s->op_st_chg.code = check->code;
1436 s->op_st_chg.status = check->status;
1437 s->op_st_chg.duration = check->duration;
1438 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001439
Emeric Brun64cc49c2017-10-03 14:46:45 +02001440 if (s->slowstart <= 0)
1441 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001442
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001443 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001444 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001445
Emeric Brun9f0b4582017-10-23 14:39:51 +02001446 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001447 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001448 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001449 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001450 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001451}
1452
Willy Tarreau8eb77842014-05-21 13:54:57 +02001453/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001454 * isn't in maintenance. The server is registered in a list to postpone the
1455 * counting of the remaining servers on the proxy and tries to grab requests
1456 * from the proxy. Maintenance servers are ignored. It stores the
1457 * <reason> if non-null as the reason for going down or the available data
1458 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001459 * up. Note that it makes use of the trash to build the log strings, so <reason>
1460 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001461 *
1462 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001463 */
Emeric Brun5a133512017-10-19 14:42:30 +02001464void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001465{
1466 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001467
Emeric Brun64cc49c2017-10-03 14:46:45 +02001468 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001469 return;
1470
Emeric Brun52a91d32017-08-31 14:41:55 +02001471 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001472 return;
1473
Emeric Brun52a91d32017-08-31 14:41:55 +02001474 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001475 *s->op_st_chg.reason = 0;
1476 s->op_st_chg.status = -1;
1477 if (reason) {
1478 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1479 }
1480 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001481 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001482 s->op_st_chg.code = check->code;
1483 s->op_st_chg.status = check->status;
1484 s->op_st_chg.duration = check->duration;
1485 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001486
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001487 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001488 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001489
Emeric Brun9f0b4582017-10-23 14:39:51 +02001490 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001491 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001492 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001493 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001494 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001495}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001496
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001497/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1498 * enforce either maint mode or drain mode. It is not allowed to set more than
1499 * one flag at once. The equivalent "inherited" flag is propagated to all
1500 * tracking servers. Maintenance mode disables health checks (but not agent
1501 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001502 * is done. If <cause> is non-null, it will be displayed at the end of the log
1503 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001504 *
1505 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001506 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001507void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001508{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001509 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001510
1511 if (!mode)
1512 return;
1513
1514 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001515 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001516 return;
1517
Emeric Brun52a91d32017-08-31 14:41:55 +02001518 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001519 if (cause)
1520 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1521
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001522 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001523 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001524
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001525 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001526 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1527 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001528 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001529
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001530 /* compute the inherited flag to propagate */
1531 if (mode & SRV_ADMF_MAINT)
1532 mode = SRV_ADMF_IMAINT;
1533 else if (mode & SRV_ADMF_DRAIN)
1534 mode = SRV_ADMF_IDRAIN;
1535
Emeric Brun9f0b4582017-10-23 14:39:51 +02001536 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001537 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001538 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001539 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001540 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001541}
1542
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001543/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1544 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1545 * than one flag at once. The equivalent "inherited" flag is propagated to all
1546 * tracking servers. Leaving maintenance mode re-enables health checks. When
1547 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001548 *
1549 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001550 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001551void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001552{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001553 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001554
1555 if (!mode)
1556 return;
1557
1558 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001559 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001560 return;
1561
Emeric Brun52a91d32017-08-31 14:41:55 +02001562 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001563
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001564 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001565 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001566
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001567 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001568 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1569 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001570 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001571
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001572 if (mode & SRV_ADMF_MAINT)
1573 mode = SRV_ADMF_IMAINT;
1574 else if (mode & SRV_ADMF_DRAIN)
1575 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001576
Emeric Brun9f0b4582017-10-23 14:39:51 +02001577 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001578 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001579 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001580 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001581 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001582}
1583
Willy Tarreau757478e2016-11-03 19:22:19 +01001584/* principle: propagate maint and drain to tracking servers. This is useful
1585 * upon startup so that inherited states are correct.
1586 */
1587static void srv_propagate_admin_state(struct server *srv)
1588{
1589 struct server *srv2;
1590
1591 if (!srv->trackers)
1592 return;
1593
1594 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001595 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001596 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001597 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001598
Emeric Brun52a91d32017-08-31 14:41:55 +02001599 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001600 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001601 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001602 }
1603}
1604
1605/* Compute and propagate the admin states for all servers in proxy <px>.
1606 * Only servers *not* tracking another one are considered, because other
1607 * ones will be handled when the server they track is visited.
1608 */
1609void srv_compute_all_admin_states(struct proxy *px)
1610{
1611 struct server *srv;
1612
1613 for (srv = px->srv; srv; srv = srv->next) {
1614 if (srv->track)
1615 continue;
1616 srv_propagate_admin_state(srv);
1617 }
1618}
1619
Willy Tarreaudff55432012-10-10 17:51:05 +02001620/* Note: must not be declared <const> as its list will be overwritten.
1621 * Please take care of keeping this list alphabetically sorted, doing so helps
1622 * all code contributors.
1623 * Optional keywords are also declared with a NULL ->parse() function so that
1624 * the config parser can report an appropriate error when a known keyword was
1625 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001626 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001627 */
1628static struct srv_kw_list srv_kws = { "ALL", { }, {
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001629 { "backup", srv_parse_backup, 0, 1, 1 }, /* Flag as backup server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001630 { "cookie", srv_parse_cookie, 1, 1, 0 }, /* Assign a cookie to the server */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001631 { "disabled", srv_parse_disabled, 0, 1, 1 }, /* Start the server in 'disabled' state */
1632 { "enabled", srv_parse_enabled, 0, 1, 1 }, /* Start the server in 'enabled' state */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001633 { "error-limit", srv_parse_error_limit, 1, 1, 0 }, /* Configure the consecutive count of check failures to consider a server on error */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001634 { "id", srv_parse_id, 1, 0, 1 }, /* set id# of server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001635 { "init-addr", srv_parse_init_addr, 1, 1, 0 }, /* */
1636 { "log-proto", srv_parse_log_proto, 1, 1, 0 }, /* Set the protocol for event messages, only relevant in a ring section */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001637 { "maxconn", srv_parse_maxconn, 1, 1, 1 }, /* Set the max number of concurrent connection */
1638 { "maxqueue", srv_parse_maxqueue, 1, 1, 1 }, /* Set the max number of connection to put in queue */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001639 { "max-reuse", srv_parse_max_reuse, 1, 1, 0 }, /* Set the max number of requests on a connection, -1 means unlimited */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001640 { "minconn", srv_parse_minconn, 1, 1, 1 }, /* Enable a dynamic maxconn limit */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001641 { "namespace", srv_parse_namespace, 1, 1, 0 }, /* Namespace the server socket belongs to (if supported) */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001642 { "no-backup", srv_parse_no_backup, 0, 1, 1 }, /* Flag as non-backup server */
1643 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1, 1 }, /* Disable use of PROXY V1 protocol */
1644 { "no-send-proxy-v2", srv_parse_no_send_proxy_v2, 0, 1, 1 }, /* Disable use of PROXY V2 protocol */
1645 { "no-tfo", srv_parse_no_tfo, 0, 1, 1 }, /* Disable use of TCP Fast Open */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001646 { "non-stick", srv_parse_non_stick, 0, 1, 0 }, /* Disable stick-table persistence */
1647 { "observe", srv_parse_observe, 1, 1, 0 }, /* Enables health adjusting based on observing communication with the server */
1648 { "on-error", srv_parse_on_error, 1, 1, 0 }, /* Configure the action on check failure */
1649 { "on-marked-down", srv_parse_on_marked_down, 1, 1, 0 }, /* Configure the action when a server is marked down */
1650 { "on-marked-up", srv_parse_on_marked_up, 1, 1, 0 }, /* Configure the action when a server is marked up */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001651 { "pool-low-conn", srv_parse_pool_low_conn, 1, 1, 1 }, /* Set the min number of orphan idle connecbefore being allowed to pick from other threads */
1652 { "pool-max-conn", srv_parse_pool_max_conn, 1, 1, 1 }, /* Set the max number of orphan idle connections, -1 means unlimited */
1653 { "pool-purge-delay", srv_parse_pool_purge_delay, 1, 1, 1 }, /* Set the time before we destroy orphan idle connections, defaults to 1s */
Amaury Denoyelle30467232021-03-12 18:03:27 +01001654 { "proto", srv_parse_proto, 1, 1, 1 }, /* Set the proto to use for all outgoing connections */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001655 { "proxy-v2-options", srv_parse_proxy_v2_options, 1, 1, 1 }, /* options for send-proxy-v2 */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001656 { "redir", srv_parse_redir, 1, 1, 0 }, /* Enable redirection mode */
Ilya Shipitsinba13f162021-03-19 22:21:44 +05001657 { "resolve-net", srv_parse_resolve_net, 1, 1, 0 }, /* Set the preferred network range for name resolution */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001658 { "resolve-opts", srv_parse_resolve_opts, 1, 1, 0 }, /* Set options for name resolution */
Ilya Shipitsinba13f162021-03-19 22:21:44 +05001659 { "resolve-prefer", srv_parse_resolve_prefer, 1, 1, 0 }, /* Set the preferred family for name resolution */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001660 { "resolvers", srv_parse_resolvers, 1, 1, 0 }, /* Configure the resolver to use for name resolution */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001661 { "send-proxy", srv_parse_send_proxy, 0, 1, 1 }, /* Enforce use of PROXY V1 protocol */
1662 { "send-proxy-v2", srv_parse_send_proxy_v2, 0, 1, 1 }, /* Enforce use of PROXY V2 protocol */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001663 { "slowstart", srv_parse_slowstart, 1, 1, 0 }, /* Set the warm-up timer for a previously failed server */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001664 { "source", srv_parse_source, -1, 1, 1 }, /* Set the source address to be used to connect to the server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001665 { "stick", srv_parse_stick, 0, 1, 0 }, /* Enable stick-table persistence */
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001666 { "tfo", srv_parse_tfo, 0, 1, 1 }, /* enable TCP Fast Open of server */
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01001667 { "track", srv_parse_track, 1, 1, 0 }, /* Set the current state of the server, tracking another one */
1668 { "socks4", srv_parse_socks4, 1, 1, 0 }, /* Set the socks4 proxy of the server*/
Amaury Denoyellefc465a52021-03-09 17:36:23 +01001669 { "usesrc", srv_parse_usesrc, 0, 1, 1 }, /* safe-guard against usesrc without preceding <source> keyword */
1670 { "weight", srv_parse_weight, 1, 1, 1 }, /* Set the load-balancing weight */
Willy Tarreaudff55432012-10-10 17:51:05 +02001671 { NULL, NULL, 0 },
1672}};
1673
Willy Tarreau0108d902018-11-25 19:14:37 +01001674INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001675
Willy Tarreau004e0452013-11-21 11:22:01 +01001676/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001677 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001678 * state is automatically disabled if the time is elapsed. If <must_update> is
1679 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001680 *
1681 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001682 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001683void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001684{
1685 struct proxy *px = sv->proxy;
1686 unsigned w;
1687
1688 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1689 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001690 if (sv->next_state == SRV_ST_STARTING)
1691 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001692 }
1693
1694 /* We must take care of not pushing the server to full throttle during slow starts.
1695 * It must also start immediately, at least at the minimal step when leaving maintenance.
1696 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001697 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001698 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1699 else
1700 w = px->lbprm.wdiv;
1701
Emeric Brun52a91d32017-08-31 14:41:55 +02001702 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001703
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001704 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001705 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001706 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001707}
1708
Willy Tarreaubaaee002006-06-26 02:48:02 +02001709/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001710 * Parses weight_str and configures sv accordingly.
1711 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001712 *
1713 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001714 */
1715const char *server_parse_weight_change_request(struct server *sv,
1716 const char *weight_str)
1717{
1718 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001719 long int w;
1720 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001721
1722 px = sv->proxy;
1723
1724 /* if the weight is terminated with '%', it is set relative to
1725 * the initial weight, otherwise it is absolute.
1726 */
1727 if (!*weight_str)
1728 return "Require <weight> or <weight%>.\n";
1729
Simon Hormanb796afa2013-02-12 10:45:53 +09001730 w = strtol(weight_str, &end, 10);
1731 if (end == weight_str)
1732 return "Empty weight string empty or preceded by garbage";
1733 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001734 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001735 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001736 /* Avoid integer overflow */
1737 if (w > 25600)
1738 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001739 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001740 if (w > 256)
1741 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001742 }
1743 else if (w < 0 || w > 256)
1744 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001745 else if (end[0] != '\0')
1746 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001747
1748 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1749 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1750
1751 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001752 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001753
1754 return NULL;
1755}
1756
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001757/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001758 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1759 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001760 * Returns:
1761 * - error string on error
1762 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001763 *
1764 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001765 */
1766const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001767 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001768{
1769 unsigned char ip[INET6_ADDRSTRLEN];
1770
1771 if (inet_pton(AF_INET6, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001772 srv_update_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001773 return NULL;
1774 }
1775 if (inet_pton(AF_INET, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001776 srv_update_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001777 return NULL;
1778 }
1779
1780 return "Could not understand IP address format.\n";
1781}
1782
Willy Tarreau46b7f532018-08-21 11:54:26 +02001783/*
1784 * Must be called with the server lock held.
1785 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001786const char *server_parse_maxconn_change_request(struct server *sv,
1787 const char *maxconn_str)
1788{
1789 long int v;
1790 char *end;
1791
1792 if (!*maxconn_str)
1793 return "Require <maxconn>.\n";
1794
1795 v = strtol(maxconn_str, &end, 10);
1796 if (end == maxconn_str)
1797 return "maxconn string empty or preceded by garbage";
1798 else if (end[0] != '\0')
1799 return "Trailing garbage in maxconn string";
1800
1801 if (sv->maxconn == sv->minconn) { // static maxconn
1802 sv->maxconn = sv->minconn = v;
1803 } else { // dynamic maxconn
1804 sv->maxconn = v;
1805 }
1806
1807 if (may_dequeue_tasks(sv, sv->proxy))
1808 process_srv_queue(sv);
1809
1810 return NULL;
1811}
1812
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001813#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001814static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1815 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001816{
1817 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001818 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001819 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001820 NULL,
1821 };
1822
1823 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001824 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001825
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001826 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001827}
1828
1829static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1830{
1831 struct sample_expr *expr;
1832
1833 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 +01001834 if (!expr) {
1835 memprintf(err, "error detected while parsing sni expression : %s", *err);
1836 return ERR_ALERT | ERR_FATAL;
1837 }
1838
1839 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1840 memprintf(err, "error detected while parsing sni expression : "
1841 " fetch method '%s' extracts information from '%s', "
1842 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001843 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001844 return ERR_ALERT | ERR_FATAL;
1845 }
1846
1847 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1848 release_sample_expr(newsrv->ssl_ctx.sni);
1849 newsrv->ssl_ctx.sni = expr;
1850
1851 return 0;
1852}
1853#endif
1854
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001855static 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 +01001856{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001857 char *msg = "error encountered while processing ";
1858 char *quote = "'";
1859 char *token = args[cur_arg];
1860
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001861 if (err && *err) {
1862 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001863 msg = *err;
1864 quote = "";
1865 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001866 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001867
1868 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
1869 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1870 file, linenum, args[0], args[1],
1871 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001872 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001873 ha_alert("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1874 file, linenum, args[0], args[1],
1875 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001876}
1877
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001878static void srv_conn_src_sport_range_cpy(struct server *srv,
1879 struct server *src)
1880{
1881 int range_sz;
1882
1883 range_sz = src->conn_src.sport_range->size;
1884 if (range_sz > 0) {
1885 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1886 if (srv->conn_src.sport_range != NULL) {
1887 int i;
1888
1889 for (i = 0; i < range_sz; i++) {
1890 srv->conn_src.sport_range->ports[i] =
1891 src->conn_src.sport_range->ports[i];
1892 }
1893 }
1894 }
1895}
1896
1897/*
1898 * Copy <src> server connection source settings to <srv> server everything needed.
1899 */
1900static void srv_conn_src_cpy(struct server *srv, struct server *src)
1901{
1902 srv->conn_src.opts = src->conn_src.opts;
1903 srv->conn_src.source_addr = src->conn_src.source_addr;
1904
1905 /* Source port range copy. */
1906 if (src->conn_src.sport_range != NULL)
1907 srv_conn_src_sport_range_cpy(srv, src);
1908
1909#ifdef CONFIG_HAP_TRANSPARENT
1910 if (src->conn_src.bind_hdr_name != NULL) {
1911 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1912 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1913 }
1914 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1915 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1916#endif
1917 if (src->conn_src.iface_name != NULL)
1918 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1919}
1920
1921/*
1922 * Copy <src> server SSL settings to <srv> server allocating
1923 * everything needed.
1924 */
1925#if defined(USE_OPENSSL)
1926static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1927{
1928 if (src->ssl_ctx.ca_file != NULL)
1929 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1930 if (src->ssl_ctx.crl_file != NULL)
1931 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001932
1933 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1934
1935 if (src->ssl_ctx.verify_host != NULL)
1936 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1937 if (src->ssl_ctx.ciphers != NULL)
1938 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02001939 if (src->ssl_ctx.options)
1940 srv->ssl_ctx.options = src->ssl_ctx.options;
1941 if (src->ssl_ctx.methods.flags)
1942 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
1943 if (src->ssl_ctx.methods.min)
1944 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
1945 if (src->ssl_ctx.methods.max)
1946 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
1947
Ilya Shipitsin2aa4b3a2021-01-07 11:55:45 +05001948#ifdef HAVE_SSL_CTX_SET_CIPHERSUITES
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001949 if (src->ssl_ctx.ciphersuites != NULL)
1950 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
1951#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001952 if (src->sni_expr != NULL)
1953 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001954
1955#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
1956 if (src->ssl_ctx.alpn_str) {
1957 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1958 if (srv->ssl_ctx.alpn_str) {
1959 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1960 src->ssl_ctx.alpn_len);
1961 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1962 }
1963 }
1964#endif
1965#ifdef OPENSSL_NPN_NEGOTIATED
1966 if (src->ssl_ctx.npn_str) {
1967 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1968 if (srv->ssl_ctx.npn_str) {
1969 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1970 src->ssl_ctx.npn_len);
1971 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1972 }
1973 }
1974#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001975}
1976#endif
1977
1978/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001979 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001980 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001981 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001982 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01001983int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001984{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001985 char *hostname_dn;
1986 int hostname_len, hostname_dn_len;
1987
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001988 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001989 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001990
Christopher Faulet67957bd2017-09-27 11:00:59 +02001991 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001992 hostname_dn = trash.area;
Emeric Brund30e9a12020-12-23 18:49:16 +01001993 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len + 1,
1994 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02001995 if (hostname_dn_len == -1)
1996 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001997
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001998
Christopher Faulet67957bd2017-09-27 11:00:59 +02001999 free(srv->hostname);
2000 free(srv->hostname_dn);
2001 srv->hostname = strdup(hostname);
2002 srv->hostname_dn = strdup(hostname_dn);
2003 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002004 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002005 goto err;
2006
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002007 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002008
2009 err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002010 ha_free(&srv->hostname);
2011 ha_free(&srv->hostname_dn);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002012 return -1;
2013}
2014
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002015/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002016 * Copy <src> server settings to <srv> server allocating
2017 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002018 * This function is not supposed to be called at any time, but only
2019 * during server settings parsing or during server allocations from
2020 * a server template, and just after having calloc()'ed a new server.
2021 * So, <src> may only be a default server (when parsing server settings)
2022 * or a server template (during server allocations from a server template).
2023 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
2024 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002025 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002026static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002027{
2028 /* Connection source settings copy */
2029 srv_conn_src_cpy(srv, src);
2030
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002031 if (srv_tmpl) {
2032 srv->addr = src->addr;
2033 srv->svc_port = src->svc_port;
2034 }
2035
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002036 srv->pp_opts = src->pp_opts;
2037 if (src->rdr_pfx != NULL) {
2038 srv->rdr_pfx = strdup(src->rdr_pfx);
2039 srv->rdr_len = src->rdr_len;
2040 }
2041 if (src->cookie != NULL) {
2042 srv->cookie = strdup(src->cookie);
2043 srv->cklen = src->cklen;
2044 }
2045 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01002046 srv->check.addr = src->check.addr;
2047 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002048 srv->check.use_ssl = src->check.use_ssl;
2049 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01002050 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01002051 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05002052 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002053 /* Note: 'flags' field has potentially been already initialized. */
2054 srv->flags |= src->flags;
2055 srv->do_check = src->do_check;
2056 srv->do_agent = src->do_agent;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002057 srv->check.inter = src->check.inter;
2058 srv->check.fastinter = src->check.fastinter;
2059 srv->check.downinter = src->check.downinter;
2060 srv->agent.use_ssl = src->agent.use_ssl;
2061 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002062
2063 if (src->agent.tcpcheck_rules) {
2064 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
2065 if (srv->agent.tcpcheck_rules) {
2066 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
2067 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
2068 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
2069 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
2070 &src->agent.tcpcheck_rules->preset_vars);
2071 }
2072 }
2073
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002074 srv->agent.inter = src->agent.inter;
2075 srv->agent.fastinter = src->agent.fastinter;
2076 srv->agent.downinter = src->agent.downinter;
2077 srv->maxqueue = src->maxqueue;
2078 srv->minconn = src->minconn;
2079 srv->maxconn = src->maxconn;
2080 srv->slowstart = src->slowstart;
2081 srv->observe = src->observe;
2082 srv->onerror = src->onerror;
2083 srv->onmarkeddown = src->onmarkeddown;
2084 srv->onmarkedup = src->onmarkedup;
2085 if (src->trackit != NULL)
2086 srv->trackit = strdup(src->trackit);
2087 srv->consecutive_errors_limit = src->consecutive_errors_limit;
2088 srv->uweight = srv->iweight = src->iweight;
2089
2090 srv->check.send_proxy = src->check.send_proxy;
2091 /* health: up, but will fall down at first failure */
2092 srv->check.rise = srv->check.health = src->check.rise;
2093 srv->check.fall = src->check.fall;
2094
2095 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02002096 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
2097 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
2098 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002099 srv->check.state |= CHK_ST_PAUSED;
2100 srv->check.health = 0;
2101 }
2102
2103 /* health: up but will fall down at first failure */
2104 srv->agent.rise = srv->agent.health = src->agent.rise;
2105 srv->agent.fall = src->agent.fall;
2106
2107 if (src->resolvers_id != NULL)
2108 srv->resolvers_id = strdup(src->resolvers_id);
Emeric Brun21fbeed2020-12-23 18:01:04 +01002109 srv->resolv_opts.family_prio = src->resolv_opts.family_prio;
2110 srv->resolv_opts.accept_duplicate_ip = src->resolv_opts.accept_duplicate_ip;
2111 srv->resolv_opts.ignore_weight = src->resolv_opts.ignore_weight;
2112 if (srv->resolv_opts.family_prio == AF_UNSPEC)
2113 srv->resolv_opts.family_prio = AF_INET6;
2114 memcpy(srv->resolv_opts.pref_net,
2115 src->resolv_opts.pref_net,
2116 sizeof srv->resolv_opts.pref_net);
2117 srv->resolv_opts.pref_net_nb = src->resolv_opts.pref_net_nb;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002118
2119 srv->init_addr_methods = src->init_addr_methods;
2120 srv->init_addr = src->init_addr;
2121#if defined(USE_OPENSSL)
2122 srv_ssl_settings_cpy(srv, src);
2123#endif
2124#ifdef TCP_USER_TIMEOUT
2125 srv->tcp_ut = src->tcp_ut;
2126#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02002127 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01002128 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02002129 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01002130 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01002131 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02002132
Olivier Houchard8da5f982017-08-04 18:35:36 +02002133 if (srv_tmpl)
2134 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08002135
2136 srv->check.via_socks4 = src->check.via_socks4;
2137 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002138}
2139
Willy Tarreau198e92a2021-03-05 10:23:32 +01002140/* allocate a server and attach it to the global servers_list. Returns
2141 * the server on success, otherwise NULL.
2142 */
William Lallemand313bfd12018-10-26 14:47:32 +02002143struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002144{
2145 struct server *srv;
2146
2147 srv = calloc(1, sizeof *srv);
2148 if (!srv)
2149 return NULL;
2150
2151 srv->obj_type = OBJ_TYPE_SERVER;
2152 srv->proxy = proxy;
Patrick Hemmer0355dab2018-05-11 12:52:31 -04002153 srv->pendconns = EB_ROOT;
Willy Tarreau2b718102021-04-21 07:32:39 +02002154 LIST_APPEND(&servers_list, &srv->global_list);
Christopher Faulet40a007c2017-07-03 15:41:01 +02002155
Emeric Brun52a91d32017-08-31 14:41:55 +02002156 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002157 srv->last_change = now.tv_sec;
2158
Christopher Faulet38290462020-04-21 11:46:40 +02002159 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002160 srv->check.status = HCHK_STATUS_INI;
2161 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01002162 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02002163 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002164
Christopher Faulet38290462020-04-21 11:46:40 +02002165 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002166 srv->agent.status = HCHK_STATUS_INI;
2167 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01002168 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002169 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
Frédéric Lécaillef46c10c2020-11-23 14:29:28 +01002170#if defined(USE_QUIC)
2171 srv->cids = EB_ROOT_UNIQUE;
2172#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002173
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01002174 srv->extra_counters = NULL;
William Lallemand3ce6eed2021-02-08 10:43:44 +01002175#ifdef USE_OPENSSL
2176 HA_RWLOCK_INIT(&srv->ssl_ctx.lock);
2177#endif
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01002178
Willy Tarreau975b1552019-06-06 16:25:55 +02002179 /* please don't put default server settings here, they are set in
Willy Tarreau144289b2021-02-12 08:19:01 +01002180 * proxy_preset_defaults().
Willy Tarreau975b1552019-06-06 16:25:55 +02002181 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002182 return srv;
2183}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002184
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002185/* Deallocate a server <srv> and its member. <srv> must be allocated.
2186 */
2187void free_server(struct server *srv)
2188{
2189 task_destroy(srv->warmup);
2190
2191 free(srv->id);
2192 free(srv->cookie);
2193 free(srv->hostname);
2194 free(srv->hostname_dn);
2195 free((char*)srv->conf.file);
2196 free(srv->per_thr);
2197 free(srv->curr_idle_thr);
2198 free(srv->resolvers_id);
2199 free(srv->addr_node.key);
Amaury Denoyellefb247942021-04-20 16:48:22 +02002200 free(srv->lb_nodes);
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002201
2202 if (srv->use_ssl == 1 || srv->check.use_ssl == 1 || (srv->proxy->options & PR_O_TCPCHK_SSL)) {
2203 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->destroy_srv)
2204 xprt_get(XPRT_SSL)->destroy_srv(srv);
2205 }
2206 HA_SPIN_DESTROY(&srv->lock);
2207
Willy Tarreau2b718102021-04-21 07:32:39 +02002208 LIST_DELETE(&srv->global_list);
Amaury Denoyelle828adf02021-03-16 17:20:15 +01002209
2210 EXTRA_COUNTERS_FREE(srv->extra_counters);
2211
2212 free(srv);
2213 srv = NULL;
2214}
2215
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002216/*
2217 * Parse as much as possible such a range string argument: low[-high]
2218 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
2219 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
2220 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
2221 * Returns 0 if succeeded, -1 if not.
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002222 */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002223static int _srv_parse_tmpl_range(struct server *srv, const char *arg,
2224 int *nb_low, int *nb_high)
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002225{
2226 char *nb_high_arg;
2227
2228 *nb_high = 0;
2229 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002230 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002231
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002232 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002233 *nb_high_arg++ = '\0';
2234 *nb_high = atoi(nb_high_arg);
2235 }
2236 else {
2237 *nb_high += *nb_low;
2238 *nb_low = 1;
2239 }
2240
2241 if (*nb_low < 0 || *nb_high < *nb_low)
2242 return -1;
2243
2244 return 0;
2245}
2246
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002247/* Parse as much as possible such a range string argument: low[-high]
2248 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
2249 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
2250 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002251 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002252 * initialize a new server on startup.
2253 *
2254 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
2255 * Returns 0 if succeeded, -1 if not.
2256 */
2257static inline void _srv_parse_set_id_from_prefix(struct server *srv,
2258 const char *prefix, int nb)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002259{
2260 chunk_printf(&trash, "%s%d", prefix, nb);
2261 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002262 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002263}
2264
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002265/* Initialize as much as possible servers from <srv> server template.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002266 * Note that a server template is a special server with
2267 * a few different parameters than a server which has
2268 * been parsed mostly the same way as a server.
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002269 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002270 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002271 * initialize a new server on startup.
2272 *
Joseph Herlant44466822018-11-15 08:57:51 -08002273 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002274 * 'srv' template included.
2275 */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002276static int _srv_parse_tmpl_init(struct server *srv, struct proxy *px)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002277{
2278 int i;
2279 struct server *newsrv;
2280
2281 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 +02002282 newsrv = new_server(px);
2283 if (!newsrv)
2284 goto err;
2285
Christopher Faulet75bef002020-11-02 22:04:55 +01002286 newsrv->conf.file = strdup(srv->conf.file);
2287 newsrv->conf.line = srv->conf.line;
2288
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002289 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002290 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002291#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2292 if (newsrv->sni_expr) {
2293 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
2294 if (!newsrv->ssl_ctx.sni)
2295 goto err;
2296 }
2297#endif
2298 /* Set this new server ID. */
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002299 _srv_parse_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002300
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002301 /* Linked backwards first. This will be restablished after parsing. */
2302 newsrv->next = px->srv;
2303 px->srv = newsrv;
2304 }
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002305 _srv_parse_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002306
2307 return i - srv->tmpl_info.nb_low;
2308
2309 err:
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002310 _srv_parse_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002311 if (newsrv) {
2312#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2313 release_sample_expr(newsrv->ssl_ctx.sni);
2314#endif
2315 free_check(&newsrv->agent);
2316 free_check(&newsrv->check);
Willy Tarreau2b718102021-04-21 07:32:39 +02002317 LIST_DELETE(&newsrv->global_list);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002318 }
2319 free(newsrv);
2320 return i - srv->tmpl_info.nb_low;
2321}
2322
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002323/* Allocate a new server pointed by <srv> and try to parse the first arguments
2324 * in <args> as an address for a server or an address-range for a template or
2325 * nothing for a default-server. <cur_arg> is incremented to the next argument.
2326 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002327 * This function is first intended to be used through parse_server to
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002328 * initialize a new server on startup.
2329 *
2330 * A mask of errors is returned. On a parsing error, ERR_FATAL is set. In case
2331 * of memory exhaustion, ERR_ABORT is set. If the server cannot be allocated,
2332 * <srv> will be set to NULL.
2333 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002334static int _srv_parse_init(struct server **srv, char **args, int *cur_arg,
2335 struct proxy *curproxy,
2336 int parse_flags, char **errmsg)
Willy Tarreau272adea2014-03-31 10:39:59 +02002337{
2338 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002339 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02002340 int err_code = 0;
Willy Tarreau07101d52015-09-08 16:16:35 +02002341 char *fqdn = NULL;
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002342 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002343
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002344 *srv = NULL;
2345
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002346 /* There is no mandatory first arguments for default server. */
2347 if (parse_flags & SRV_PARSE_PARSE_ADDR) {
2348 if (parse_flags & SRV_PARSE_TEMPLATE) {
2349 if (!*args[3]) {
2350 /* 'server-template' line number of argument check. */
2351 memprintf(errmsg, "'%s' expects <prefix> <nb | range> <addr>[:<port>] as arguments.",
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002352 args[0]);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002353 err_code |= ERR_ALERT | ERR_FATAL;
2354 goto out;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002355 }
2356
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002357 err = invalid_prefix_char(args[1]);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002358 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002359 else {
2360 if (!*args[2]) {
2361 /* 'server' line number of argument check. */
2362 memprintf(errmsg, "'%s' expects <name> and <addr>[:<port>] as arguments.",
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002363 args[0]);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002364 err_code |= ERR_ALERT | ERR_FATAL;
2365 goto out;
2366 }
2367
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002368 err = invalid_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002369 }
2370
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002371 if (err) {
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002372 memprintf(errmsg, "character '%c' is not permitted in %s %s '%s'.",
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002373 *err, args[0], !(parse_flags & SRV_PARSE_TEMPLATE) ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002374 err_code |= ERR_ALERT | ERR_FATAL;
2375 goto out;
2376 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002377 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002378
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002379 *cur_arg = 2;
2380 if (parse_flags & SRV_PARSE_TEMPLATE) {
2381 /* Parse server-template <nb | range> arg. */
2382 if (_srv_parse_tmpl_range(newsrv, args[*cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
2383 memprintf(errmsg, "Wrong %s number or range arg '%s'.",
2384 args[0], args[*cur_arg]);
2385 err_code |= ERR_ALERT | ERR_FATAL;
2386 goto out;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002387 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002388 (*cur_arg)++;
2389 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002390
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002391 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
2392 struct sockaddr_storage *sk;
2393 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002394
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002395 *srv = newsrv = new_server(curproxy);
2396 if (!newsrv) {
2397 memprintf(errmsg, "out of memory.");
2398 err_code |= ERR_ALERT | ERR_ABORT;
2399 goto out;
2400 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002401
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002402 if (parse_flags & SRV_PARSE_TEMPLATE) {
2403 newsrv->tmpl_info.nb_low = tmpl_range_low;
2404 newsrv->tmpl_info.nb_high = tmpl_range_high;
2405 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002406
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002407 if (parse_flags & SRV_PARSE_DYNAMIC)
2408 newsrv->flags |= SRV_F_DYNAMIC;
2409
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002410 /* Note: for a server template, its id is its prefix.
2411 * This is a temporary id which will be used for server allocations to come
2412 * after parsing.
2413 */
2414 if (!(parse_flags & SRV_PARSE_TEMPLATE))
2415 newsrv->id = strdup(args[1]);
2416 else
2417 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002418
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002419 /* several ways to check the port component :
2420 * - IP => port=+0, relative (IPv4 only)
2421 * - IP: => port=+0, relative
2422 * - IP:N => port=N, absolute
2423 * - IP:+N => port=+N, relative
2424 * - IP:-N => port=-N, relative
2425 */
2426 if (!(parse_flags & SRV_PARSE_PARSE_ADDR))
2427 goto skip_addr;
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002428
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002429 sk = str2sa_range(args[*cur_arg], &port, &port1, &port2, NULL, NULL,
2430 errmsg, NULL, &fqdn,
2431 (parse_flags & SRV_PARSE_INITIAL_RESOLVE ? PA_O_RESOLVE : 0) | PA_O_PORT_OK | PA_O_PORT_OFS | PA_O_STREAM | PA_O_XPRT | PA_O_CONNECT);
2432 if (!sk) {
2433 memprintf(errmsg, "'%s %s' : %s", args[0], args[1], *errmsg);
2434 err_code |= ERR_ALERT | ERR_FATAL;
2435 goto out;
2436 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002437
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002438 if (!port1 || !port2) {
2439 /* no port specified, +offset, -offset */
2440 newsrv->flags |= SRV_F_MAPPORTS;
2441 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002442
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002443 /* save hostname and create associated name resolution */
2444 if (fqdn) {
2445 if (fqdn[0] == '_') { /* SRV record */
2446 /* Check if a SRV request already exists, and if not, create it */
2447 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
2448 newsrv->srvrq = new_resolv_srvrq(newsrv, fqdn);
2449 if (newsrv->srvrq == NULL) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002450 err_code |= ERR_ALERT | ERR_FATAL;
2451 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002452 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002453 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002454 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
2455 memprintf(errmsg, "Can't create DNS resolution for server '%s'",
2456 newsrv->id);
Willy Tarreau272adea2014-03-31 10:39:59 +02002457 err_code |= ERR_ALERT | ERR_FATAL;
2458 goto out;
2459 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002460 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002461
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002462 newsrv->addr = *sk;
2463 newsrv->svc_port = port;
2464 // we don't need to lock the server here, because
2465 // we are in the process of initializing
2466 srv_set_addr_desc(newsrv);
2467
2468 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
2469 memprintf(errmsg, "Unknown protocol family %d '%s'",
2470 newsrv->addr.ss_family, args[*cur_arg]);
2471 err_code |= ERR_ALERT | ERR_FATAL;
2472 goto out;
Willy Tarreau272adea2014-03-31 10:39:59 +02002473 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002474
2475 (*cur_arg)++;
2476 skip_addr:
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002477 if (!(parse_flags & SRV_PARSE_DYNAMIC)) {
2478 /* Copy default server settings to new server */
2479 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
2480 } else {
2481 /* Initialize dynamic server weight to 1 */
2482 newsrv->uweight = newsrv->iweight = 1;
2483
2484 /* A dynamic server is disabled on startup */
2485 newsrv->next_admin = SRV_ADMF_FMAINT;
2486 newsrv->next_state = SRV_ST_STOPPED;
2487 server_recalc_eweight(newsrv, 0);
2488 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002489 HA_SPIN_INIT(&newsrv->lock);
2490 }
2491 else {
2492 *srv = newsrv = &curproxy->defsrv;
2493 *cur_arg = 1;
2494 newsrv->resolv_opts.family_prio = AF_INET6;
2495 newsrv->resolv_opts.accept_duplicate_ip = 0;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002496 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002497
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002498 free(fqdn);
2499 return 0;
Willy Tarreau9faebe32019-06-07 19:00:37 +02002500
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002501out:
2502 free(fqdn);
2503 return err_code;
2504}
Willy Tarreau272adea2014-03-31 10:39:59 +02002505
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002506/* Parse the server keyword in <args>.
2507 * <cur_arg> is incremented beyond the keyword optional value. Note that this
2508 * might not be the case if an error is reported.
2509 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002510 * This function is first intended to be used through parse_server to
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002511 * initialize a new server on startup.
2512 *
2513 * A mask of errors is returned. ERR_FATAL is set if the parsing should be
2514 * interrupted.
2515 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002516static int _srv_parse_kw(struct server *srv, char **args, int *cur_arg,
2517 struct proxy *curproxy,
2518 int parse_flags, char **errmsg)
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002519{
2520 int err_code = 0;
2521 struct srv_kw *kw;
2522 const char *best;
Willy Tarreau272adea2014-03-31 10:39:59 +02002523
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002524 kw = srv_find_kw(args[*cur_arg]);
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002525 if (!kw) {
2526 best = srv_find_best_kw(args[*cur_arg]);
2527 if (best)
2528 memprintf(errmsg, "unknown keyword '%s'; did you mean '%s' maybe ?",
2529 args[*cur_arg], best);
2530 else
2531 memprintf(errmsg, "unknown keyword '%s'.",
2532 args[*cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002533
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002534 return ERR_ALERT | ERR_FATAL;
2535 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002536
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002537 if (!kw->parse) {
2538 memprintf(errmsg, "'%s' option is not implemented in this version (check build options)",
2539 args[*cur_arg]);
2540 err_code = ERR_ALERT | ERR_FATAL;
2541 goto out;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002542 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002543
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002544 if ((parse_flags & SRV_PARSE_DEFAULT_SERVER) && !kw->default_ok) {
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002545 memprintf(errmsg, "'%s' option is not accepted in default-server sections",
2546 args[*cur_arg]);
2547 err_code = ERR_ALERT;
2548 goto out;
2549 }
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002550 else if ((parse_flags & SRV_PARSE_DYNAMIC) && !kw->dynamic_ok) {
2551 memprintf(errmsg, "'%s' option is not accepted for dynamic server",
2552 args[*cur_arg]);
2553 err_code |= ERR_ALERT;
2554 goto out;
2555 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002556
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002557 err_code = kw->parse(args, cur_arg, curproxy, srv, errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002558
2559out:
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002560 if (kw->skip != -1)
2561 *cur_arg += 1 + kw->skip;
2562
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002563 return err_code;
2564}
2565
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002566#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002567/* This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002568 * initialize a new server on startup.
2569 */
2570static int _srv_parse_sni_expr_init(char **args, int cur_arg,
2571 struct server *srv, struct proxy *proxy,
2572 char **errmsg)
2573{
2574 int ret;
2575
2576 if (!srv->sni_expr)
2577 return 0;
2578
2579 ret = server_parse_sni_expr(srv, proxy, errmsg);
2580 if (!ret)
2581 return 0;
2582
2583 return ret;
2584}
2585#endif
2586
2587/* Server initializations finalization.
2588 * Initialize health check, agent check and SNI expression if enabled.
2589 * Must not be called for a default server instance.
2590 *
Ilya Shipitsinba13f162021-03-19 22:21:44 +05002591 * This function is first intended to be used through parse_server to
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002592 * initialize a new server on startup.
2593 */
2594static int _srv_parse_finalize(char **args, int cur_arg,
2595 struct server *srv, struct proxy *px,
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002596 int parse_flags, char **errmsg)
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002597{
2598#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2599 int ret;
2600#endif
2601
2602 if (srv->do_check && srv->trackit) {
2603 memprintf(errmsg, "unable to enable checks and tracking at the same time!");
2604 return ERR_ALERT | ERR_FATAL;
2605 }
2606
2607 if (srv->do_agent && !srv->agent.port) {
2608 memprintf(errmsg, "server %s does not have agent port. Agent check has been disabled.",
2609 srv->id);
2610 return ERR_ALERT | ERR_FATAL;
2611 }
2612
2613#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2614 if ((ret = _srv_parse_sni_expr_init(args, cur_arg, srv, px, errmsg)) != 0)
2615 return ret;
2616#endif
2617
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002618 /* A dynamic server is disabled on startup. It must not be counted as
2619 * an active backend entry.
2620 */
2621 if (!(parse_flags & SRV_PARSE_DYNAMIC)) {
2622 if (srv->flags & SRV_F_BACKUP)
2623 px->srv_bck++;
2624 else
2625 px->srv_act++;
2626 }
2627
Amaury Denoyelle7d27efe2021-03-17 14:25:39 +01002628 srv_lb_commit_status(srv);
2629
2630 return 0;
2631}
2632
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002633int parse_server(const char *file, int linenum, char **args,
2634 struct proxy *curproxy, const struct proxy *defproxy,
2635 int parse_flags)
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002636{
2637 struct server *newsrv = NULL;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002638 char *errmsg = NULL;
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002639 int err_code = 0;
2640
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002641 int cur_arg;
Willy Tarreau272adea2014-03-31 10:39:59 +02002642
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002643 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER) && curproxy == defproxy) {
2644 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
2645 err_code |= ERR_ALERT | ERR_FATAL;
2646 goto out;
2647 }
2648 else if (failifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL)) {
2649 err_code |= ERR_ALERT | ERR_FATAL;
2650 goto out;
2651 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002652
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002653 if ((parse_flags & (SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_PARSE_ADDR)) ==
2654 (SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_PARSE_ADDR)) {
2655 if (!*args[2])
2656 return 0;
2657 }
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002658
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002659 err_code = _srv_parse_init(&newsrv, args, &cur_arg, curproxy,
2660 parse_flags, &errmsg);
2661 if (errmsg) {
2662 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
2663 free(errmsg);
2664 }
Amaury Denoyellecf58dd72021-03-08 16:35:54 +01002665
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002666 /* the servers are linked backwards first */
2667 if (newsrv && !(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
2668 newsrv->next = curproxy->srv;
2669 curproxy->srv = newsrv;
2670 }
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002671
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002672 if (err_code & ERR_CODE)
2673 goto out;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002674
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002675 newsrv->conf.file = strdup(file);
2676 newsrv->conf.line = linenum;
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002677
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002678 while (*args[cur_arg]) {
2679 errmsg = NULL;
2680 err_code = _srv_parse_kw(newsrv, args, &cur_arg, curproxy,
2681 parse_flags, &errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002682
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002683 if (err_code & ERR_ALERT) {
2684 display_parser_err(file, linenum, args, cur_arg, err_code, &errmsg);
2685 free(errmsg);
Amaury Denoyellea8f442e2021-03-08 10:29:33 +01002686 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002687
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002688 if (err_code & ERR_FATAL)
2689 goto out;
2690 }
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002691
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002692 if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002693 err_code |= _srv_parse_finalize(args, cur_arg, newsrv, curproxy, parse_flags, &errmsg);
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002694 if (err_code) {
2695 display_parser_err(file, linenum, args, cur_arg, err_code, &errmsg);
2696 free(errmsg);
Amaury Denoyelle9394a942021-03-08 11:20:52 +01002697 }
2698
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002699 if (err_code & ERR_FATAL)
2700 goto out;
Willy Tarreau272adea2014-03-31 10:39:59 +02002701 }
Amaury Denoyellecf58dd72021-03-08 16:35:54 +01002702
Amaury Denoyelle30c05372021-03-08 16:36:46 +01002703 if (parse_flags & SRV_PARSE_TEMPLATE)
2704 _srv_parse_tmpl_init(newsrv, curproxy);
2705
Amaury Denoyelleda0e7f62021-03-30 10:26:27 +02002706 HA_DIAG_WARNING_COND(!newsrv->uweight,
2707 "parsing [%s:%d] : 'server %s' : configured with weight of 0 will never be selected by load balancing algorithms\n",
2708 file, linenum, newsrv->id);
2709
Willy Tarreau272adea2014-03-31 10:39:59 +02002710 return 0;
2711
2712 out:
Willy Tarreau272adea2014-03-31 10:39:59 +02002713 return err_code;
2714}
2715
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002716/* Returns a pointer to the first server matching either id <id>.
2717 * NULL is returned if no match is found.
2718 * the lookup is performed in the backend <bk>
2719 */
2720struct server *server_find_by_id(struct proxy *bk, int id)
2721{
2722 struct eb32_node *eb32;
2723 struct server *curserver;
2724
2725 if (!bk || (id ==0))
2726 return NULL;
2727
2728 /* <bk> has no backend capabilities, so it can't have a server */
2729 if (!(bk->cap & PR_CAP_BE))
2730 return NULL;
2731
2732 curserver = NULL;
2733
2734 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2735 if (eb32)
2736 curserver = container_of(eb32, struct server, conf.id);
2737
2738 return curserver;
2739}
2740
2741/* Returns a pointer to the first server matching either name <name>, or id
2742 * if <name> starts with a '#'. NULL is returned if no match is found.
2743 * the lookup is performed in the backend <bk>
2744 */
2745struct server *server_find_by_name(struct proxy *bk, const char *name)
2746{
2747 struct server *curserver;
2748
2749 if (!bk || !name)
2750 return NULL;
2751
2752 /* <bk> has no backend capabilities, so it can't have a server */
2753 if (!(bk->cap & PR_CAP_BE))
2754 return NULL;
2755
2756 curserver = NULL;
2757 if (*name == '#') {
2758 curserver = server_find_by_id(bk, atoi(name + 1));
2759 if (curserver)
2760 return curserver;
2761 }
2762 else {
2763 curserver = bk->srv;
2764
2765 while (curserver && (strcmp(curserver->id, name) != 0))
2766 curserver = curserver->next;
2767
2768 if (curserver)
2769 return curserver;
2770 }
2771
2772 return NULL;
2773}
2774
2775struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2776{
2777 struct server *byname;
2778 struct server *byid;
2779
2780 if (!name && !id)
2781 return NULL;
2782
2783 if (diff)
2784 *diff = 0;
2785
2786 byname = byid = NULL;
2787
2788 if (name) {
2789 byname = server_find_by_name(bk, name);
2790 if (byname && (!id || byname->puid == id))
2791 return byname;
2792 }
2793
2794 /* remaining possibilities :
2795 * - name not set
2796 * - name set but not found
2797 * - name found but ID doesn't match
2798 */
2799 if (id) {
2800 byid = server_find_by_id(bk, id);
2801 if (byid) {
2802 if (byname) {
2803 /* use id only if forced by configuration */
2804 if (byid->flags & SRV_F_FORCED_ID) {
2805 if (diff)
2806 *diff |= 2;
2807 return byid;
2808 }
2809 else {
2810 if (diff)
2811 *diff |= 1;
2812 return byname;
2813 }
2814 }
2815
2816 /* remaining possibilities:
2817 * - name not set
2818 * - name set but not found
2819 */
2820 if (name && diff)
2821 *diff |= 2;
2822 return byid;
2823 }
2824
2825 /* id bot found */
2826 if (byname) {
2827 if (diff)
2828 *diff |= 1;
2829 return byname;
2830 }
2831 }
2832
2833 return NULL;
2834}
2835
Simon Horman7d09b9a2013-02-12 10:45:51 +09002836/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02002837 * update a server's current IP address.
2838 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
2839 * ip is in network format.
2840 * updater is a string which contains an information about the requester of the update.
2841 * updater is used if not NULL.
2842 *
2843 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02002844 *
2845 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02002846 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002847int srv_update_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02002848{
Christopher Fauletd6c6b5f2020-09-08 10:27:24 +02002849 /* save the new IP family & address if necessary */
2850 switch (ip_sin_family) {
2851 case AF_INET:
2852 if (s->addr.ss_family == ip_sin_family &&
2853 !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
2854 return 0;
2855 break;
2856 case AF_INET6:
2857 if (s->addr.ss_family == ip_sin_family &&
2858 !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
2859 return 0;
2860 break;
2861 };
2862
Baptiste Assmann14e40142015-04-14 01:13:07 +02002863 /* generates a log line and a warning on stderr */
2864 if (1) {
2865 /* book enough space for both IPv4 and IPv6 */
2866 char oldip[INET6_ADDRSTRLEN];
2867 char newip[INET6_ADDRSTRLEN];
2868
2869 memset(oldip, '\0', INET6_ADDRSTRLEN);
2870 memset(newip, '\0', INET6_ADDRSTRLEN);
2871
2872 /* copy old IP address in a string */
2873 switch (s->addr.ss_family) {
2874 case AF_INET:
2875 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
2876 break;
2877 case AF_INET6:
2878 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
2879 break;
Christopher Fauletb0b76072020-09-08 10:38:40 +02002880 default:
2881 strcpy(oldip, "(none)");
2882 break;
Baptiste Assmann14e40142015-04-14 01:13:07 +02002883 };
2884
2885 /* copy new IP address in a string */
2886 switch (ip_sin_family) {
2887 case AF_INET:
2888 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
2889 break;
2890 case AF_INET6:
2891 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
2892 break;
2893 };
2894
2895 /* save log line into a buffer */
2896 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
2897 s->proxy->id, s->id, oldip, newip, updater);
2898
2899 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002900 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002901
2902 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002903 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002904 }
2905
2906 /* save the new IP family */
2907 s->addr.ss_family = ip_sin_family;
2908 /* save the new IP address */
2909 switch (ip_sin_family) {
2910 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02002911 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002912 break;
2913 case AF_INET6:
2914 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
2915 break;
2916 };
Olivier Houchard4e694042017-03-14 20:01:29 +01002917 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07002918 srv_set_addr_desc(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002919
2920 return 0;
2921}
2922
William Dauchy7cabc062021-02-11 22:51:24 +01002923/* update agent health check address and port
2924 * addr can be ip4/ip6 or a hostname
2925 * if one error occurs, don't apply anything
2926 * must be called with the server lock held.
2927 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002928const char *srv_update_agent_addr_port(struct server *s, const char *addr, const char *port)
William Dauchy7cabc062021-02-11 22:51:24 +01002929{
2930 struct sockaddr_storage sk;
2931 struct buffer *msg;
2932 int new_port;
2933
2934 msg = get_trash_chunk();
2935 chunk_reset(msg);
2936
2937 if (!(s->agent.state & CHK_ST_ENABLED)) {
2938 chunk_strcat(msg, "agent checks are not enabled on this server");
2939 goto out;
2940 }
2941 if (addr) {
2942 memset(&sk, 0, sizeof(struct sockaddr_storage));
2943 if (str2ip(addr, &sk) == NULL) {
2944 chunk_appendf(msg, "invalid addr '%s'", addr);
2945 goto out;
2946 }
2947 }
2948 if (port) {
2949 if (strl2irc(port, strlen(port), &new_port) != 0) {
2950 chunk_appendf(msg, "provided port is not an integer");
2951 goto out;
2952 }
2953 if (new_port < 0 || new_port > 65535) {
2954 chunk_appendf(msg, "provided port is invalid");
2955 goto out;
2956 }
2957 }
2958out:
2959 if (msg->data)
2960 return msg->area;
2961 else {
2962 if (addr)
2963 set_srv_agent_addr(s, &sk);
2964 if (port)
2965 set_srv_agent_port(s, new_port);
2966 }
2967 return NULL;
2968}
2969
William Dauchyb456e1f2021-02-11 22:51:23 +01002970/* update server health check address and port
2971 * addr must be ip4 or ip6, it won't be resolved
2972 * if one error occurs, don't apply anything
2973 * must be called with the server lock held.
2974 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002975const char *srv_update_check_addr_port(struct server *s, const char *addr, const char *port)
William Dauchyb456e1f2021-02-11 22:51:23 +01002976{
2977 struct sockaddr_storage sk;
2978 struct buffer *msg;
2979 int new_port;
2980
2981 msg = get_trash_chunk();
2982 chunk_reset(msg);
2983
2984 if (!(s->check.state & CHK_ST_ENABLED)) {
2985 chunk_strcat(msg, "health checks are not enabled on this server");
2986 goto out;
2987 }
2988 if (addr) {
2989 memset(&sk, 0, sizeof(struct sockaddr_storage));
2990 if (str2ip2(addr, &sk, 0) == NULL) {
2991 chunk_appendf(msg, "invalid addr '%s'", addr);
2992 goto out;
2993 }
2994 }
2995 if (port) {
2996 if (strl2irc(port, strlen(port), &new_port) != 0) {
2997 chunk_appendf(msg, "provided port is not an integer");
2998 goto out;
2999 }
3000 if (new_port < 0 || new_port > 65535) {
3001 chunk_appendf(msg, "provided port is invalid");
3002 goto out;
3003 }
3004 /* prevent the update of port to 0 if MAPPORTS are in use */
3005 if ((s->flags & SRV_F_MAPPORTS) && new_port == 0) {
3006 chunk_appendf(msg, "can't unset 'port' since MAPPORTS is in use");
3007 goto out;
3008 }
3009 }
3010out:
3011 if (msg->data)
3012 return msg->area;
3013 else {
3014 if (addr)
3015 s->check.addr = sk;
3016 if (port)
3017 s->check.port = new_port;
3018 }
3019 return NULL;
3020}
3021
Baptiste Assmann14e40142015-04-14 01:13:07 +02003022/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003023 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3024 *
3025 * Caller can pass its name through <updater> to get it integrated in the response message
3026 * returned by the function.
3027 *
3028 * The function first does the following, in that order:
3029 * - validates the new addr and/or port
3030 * - checks if an update is required (new IP or port is different than current ones)
3031 * - checks the update is allowed:
3032 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3033 * - allow all changes if no CHECKS are configured
3034 * - if CHECK is configured:
3035 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3036 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3037 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02003038 *
3039 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003040 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003041const char *srv_update_addr_port(struct server *s, const char *addr, const char *port, char *updater)
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003042{
3043 struct sockaddr_storage sa;
3044 int ret, port_change_required;
3045 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003046 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02003047 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003048 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003049
3050 msg = get_trash_chunk();
3051 chunk_reset(msg);
3052
3053 if (addr) {
3054 memset(&sa, 0, sizeof(struct sockaddr_storage));
3055 if (str2ip2(addr, &sa, 0) == NULL) {
3056 chunk_printf(msg, "Invalid addr '%s'", addr);
3057 goto out;
3058 }
3059
3060 /* changes are allowed on AF_INET* families only */
3061 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3062 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3063 goto out;
3064 }
3065
3066 /* collecting data currently setup */
3067 memset(current_addr, '\0', sizeof(current_addr));
3068 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3069 /* changes are allowed on AF_INET* families only */
3070 if ((ret != AF_INET) && (ret != AF_INET6)) {
3071 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3072 goto out;
3073 }
3074
3075 /* applying ADDR changes if required and allowed
3076 * ipcmp returns 0 when both ADDR are the same
3077 */
3078 if (ipcmp(&s->addr, &sa) == 0) {
3079 chunk_appendf(msg, "no need to change the addr");
3080 goto port;
3081 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003082 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003083 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003084
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003085 /* update report for caller */
3086 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3087 }
3088
3089 port:
3090 if (port) {
3091 char sign = '\0';
3092 char *endptr;
3093
3094 if (addr)
3095 chunk_appendf(msg, ", ");
3096
3097 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003098 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003099
3100 /* check if PORT change is required */
3101 port_change_required = 0;
3102
3103 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003104 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003105 new_port = strtol(port, &endptr, 10);
3106 if ((errno != 0) || (port == endptr)) {
3107 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3108 goto out;
3109 }
3110
3111 /* check if caller triggers a port mapped or offset */
3112 if (sign == '-' || (sign == '+')) {
3113 /* check if server currently uses port map */
3114 if (!(s->flags & SRV_F_MAPPORTS)) {
3115 /* switch from fixed port to port map mandatorily triggers
3116 * a port change */
3117 port_change_required = 1;
3118 /* check is configured
3119 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3120 * prevent PORT change if check doesn't have it's dedicated port while switching
3121 * to port mapping */
William Dauchy69f118d2021-02-03 22:30:07 +01003122 if (!s->check.port) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003123 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.");
3124 goto out;
3125 }
3126 }
3127 /* we're already using port maps */
3128 else {
3129 port_change_required = current_port != new_port;
3130 }
3131 }
3132 /* fixed port */
3133 else {
3134 port_change_required = current_port != new_port;
3135 }
3136
3137 /* applying PORT changes if required and update response message */
3138 if (port_change_required) {
3139 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003140 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003141 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003142
3143 /* prepare message */
3144 chunk_appendf(msg, "port changed from '");
3145 if (s->flags & SRV_F_MAPPORTS)
3146 chunk_appendf(msg, "+");
3147 chunk_appendf(msg, "%d' to '", current_port);
3148
3149 if (sign == '-') {
3150 s->flags |= SRV_F_MAPPORTS;
3151 chunk_appendf(msg, "%c", sign);
3152 /* just use for result output */
3153 new_port = -new_port;
3154 }
3155 else if (sign == '+') {
3156 s->flags |= SRV_F_MAPPORTS;
3157 chunk_appendf(msg, "%c", sign);
3158 }
3159 else {
3160 s->flags &= ~SRV_F_MAPPORTS;
3161 }
3162
3163 chunk_appendf(msg, "%d'", new_port);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003164 }
3165 else {
3166 chunk_appendf(msg, "no need to change the port");
3167 }
3168 }
3169
3170out:
William Dauchy6318d332020-05-02 21:52:36 +02003171 if (changed) {
3172 /* force connection cleanup on the given server */
3173 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01003174 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07003175 srv_set_addr_desc(s);
William Dauchy6318d332020-05-02 21:52:36 +02003176 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003177 if (updater)
3178 chunk_appendf(msg, " by '%s'", updater);
3179 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003180 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003181}
3182
Christopher Faulet5efdef22021-03-11 18:03:21 +01003183/*
3184 * update server status based on result of SRV resolution
3185 * returns:
3186 * 0 if server status is updated
3187 * 1 if server status has not changed
3188 *
3189 * Must be called with the server lock held.
3190 */
3191int srvrq_update_srv_status(struct server *s, int has_no_ip)
3192{
3193 if (!s->srvrq)
3194 return 1;
3195
3196 /* since this server has an IP, it can go back in production */
3197 if (has_no_ip == 0) {
3198 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3199 return 1;
3200 }
3201
3202 if (s->next_admin & SRV_ADMF_RMAINT)
3203 return 1;
3204
3205 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
3206 return 0;
3207}
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003208
3209/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003210 * update server status based on result of name resolution
3211 * returns:
3212 * 0 if server status is updated
3213 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003214 *
3215 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003216 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003217int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003218{
Emeric Brun750fe792020-12-23 16:51:12 +01003219 struct resolvers *resolvers = s->resolvers;
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003220 struct resolv_resolution *resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003221 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003222
Jerome Magnin012261a2020-07-28 13:38:22 +02003223 /* If resolution is NULL we're dealing with SRV records Additional records */
Christopher Faulet5efdef22021-03-11 18:03:21 +01003224 if (resolution == NULL)
3225 return srvrq_update_srv_status(s, has_no_ip);
Jerome Magnin012261a2020-07-28 13:38:22 +02003226
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003227 switch (resolution->status) {
3228 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003229 /* status when HAProxy has just (re)started.
3230 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003231 break;
3232
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003233 case RSLV_STATUS_VALID:
3234 /*
3235 * resume health checks
3236 * server will be turned back on if health check is safe
3237 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003238 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003239 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003240 return 1;
3241 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3242 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003243 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003244 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003245
Emeric Brun52a91d32017-08-31 14:41:55 +02003246 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003247 return 1;
3248 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3249 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3250 s->proxy->id, s->id);
3251
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003252 ha_warning("%s.\n", trash.area);
3253 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003254 return 0;
3255
3256 case RSLV_STATUS_NX:
3257 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003258 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3259 if (!tick_is_expired(exp, now_ms))
3260 break;
3261
3262 if (s->next_admin & SRV_ADMF_RMAINT)
3263 return 1;
3264 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3265 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003266
3267 case RSLV_STATUS_TIMEOUT:
3268 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003269 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3270 if (!tick_is_expired(exp, now_ms))
3271 break;
3272
3273 if (s->next_admin & SRV_ADMF_RMAINT)
3274 return 1;
3275 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3276 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003277
3278 case RSLV_STATUS_REFUSED:
3279 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003280 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3281 if (!tick_is_expired(exp, now_ms))
3282 break;
3283
3284 if (s->next_admin & SRV_ADMF_RMAINT)
3285 return 1;
3286 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3287 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003288
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003289 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003290 /* stop server if resolution failed for a long enough period */
3291 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3292 if (!tick_is_expired(exp, now_ms))
3293 break;
3294
3295 if (s->next_admin & SRV_ADMF_RMAINT)
3296 return 1;
3297 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3298 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003299 }
3300
3301 return 1;
3302}
3303
3304/*
3305 * Server Name Resolution valid response callback
3306 * It expects:
3307 * - <nameserver>: the name server which answered the valid response
3308 * - <response>: buffer containing a valid DNS response
3309 * - <response_len>: size of <response>
3310 * It performs the following actions:
3311 * - ignore response if current ip found and server family not met
3312 * - update with first new ip found if family is met and current IP is not found
3313 * returns:
3314 * 0 on error
3315 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003316 *
3317 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003318 */
Emeric Brun08622d32020-12-23 17:41:43 +01003319int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *counters)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003320{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003321 struct server *s = NULL;
Emeric Brun08622d32020-12-23 17:41:43 +01003322 struct resolv_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003323 void *serverip, *firstip;
3324 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003325 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003326 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003327 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003328
Christopher Faulet67957bd2017-09-27 11:00:59 +02003329 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003330 if (!s)
3331 return 1;
3332
Christopher Faulet49531e82021-03-10 15:07:27 +01003333 if (s->srvrq) {
3334 struct resolv_answer_item *srv_item;
3335
3336 /* If DNS resolution is disabled ignore it. */
3337 if (s->flags & SRV_F_NO_RESOLUTION)
3338 return 1;
3339
3340 /* The server is based on a SRV record, thus, find the
3341 * associated answer record. If not found, it means the SRV item
3342 * has expired and this resolution must be ignored.
3343 */
3344 srv_item = find_srvrq_answer_record(requester);
3345 if (!srv_item)
3346 return 1;
3347 }
3348
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003349 resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
Christopher Faulet49531e82021-03-10 15:07:27 +01003350 if (!resolution)
3351 return 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003352
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003353 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003354 firstip = NULL; /* pointer to the first valid response found */
3355 /* it will be used as the new IP if a change is required */
3356 firstip_sin_family = AF_UNSPEC;
3357 serverip = NULL; /* current server IP address */
3358
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003359 /* initializing server IP pointer */
3360 server_sin_family = s->addr.ss_family;
3361 switch (server_sin_family) {
3362 case AF_INET:
3363 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3364 break;
3365
3366 case AF_INET6:
3367 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3368 break;
3369
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003370 case AF_UNSPEC:
3371 break;
3372
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003373 default:
3374 goto invalid;
3375 }
3376
Emeric Brund30e9a12020-12-23 18:49:16 +01003377 ret = resolv_get_ip_from_response(&resolution->response, &s->resolv_opts,
3378 serverip, server_sin_family, &firstip,
3379 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003380
3381 switch (ret) {
Emeric Brun456de772020-12-23 18:17:31 +01003382 case RSLV_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003383 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003384
Emeric Brun456de772020-12-23 18:17:31 +01003385 case RSLV_UPD_SRVIP_NOT_FOUND:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003386 goto save_ip;
3387
Emeric Brun456de772020-12-23 18:17:31 +01003388 case RSLV_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003389 goto invalid;
3390
Emeric Brun456de772020-12-23 18:17:31 +01003391 case RSLV_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003392 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003393 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003394
Emeric Brun456de772020-12-23 18:17:31 +01003395 case RSLV_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003396 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003397 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003398 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003399
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003400 default:
3401 goto invalid;
3402
3403 }
3404
3405 save_ip:
Emeric Brun50c870e2021-01-04 10:40:46 +01003406 if (counters) {
3407 counters->update++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003408 /* save the first ip we found */
Emeric Brun50c870e2021-01-04 10:40:46 +01003409 chunk_printf(chk, "%s/%s", counters->pid, counters->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003410 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003411 else
3412 chunk_printf(chk, "DNS cache");
Christopher Faulet69beaa92021-02-16 12:07:47 +01003413 srv_update_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003414
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003415 update_status:
Christopher Faulet49531e82021-03-10 15:07:27 +01003416
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003417 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003418 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003419
3420 invalid:
Emeric Brun50c870e2021-01-04 10:40:46 +01003421 if (counters) {
3422 counters->invalid++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003423 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003424 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003425 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003426 return 0;
3427}
3428
3429/*
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003430 * SRV record error management callback
3431 * returns:
3432 * 0 on error
3433 * 1 when no error or safe ignore
3434 *
3435 * Grabs the server's lock.
3436 */
3437int srvrq_resolution_error_cb(struct resolv_requester *requester, int error_code)
3438{
3439 struct server *s;
3440 struct resolv_srvrq *srvrq;
3441 struct resolv_resolution *res;
3442 struct resolvers *resolvers;
3443 int exp;
3444
3445 /* SRV records */
3446 srvrq = objt_resolv_srvrq(requester->owner);
3447 if (!srvrq)
3448 return 1;
3449
3450 resolvers = srvrq->resolvers;
3451 res = requester->resolution;
3452
3453 switch (res->status) {
3454
3455 case RSLV_STATUS_NX:
3456 /* stop server if resolution is NX for a long enough period */
3457 exp = tick_add(res->last_valid, resolvers->hold.nx);
3458 if (!tick_is_expired(exp, now_ms))
3459 return 1;
3460 break;
3461
3462 case RSLV_STATUS_TIMEOUT:
3463 /* stop server if resolution is TIMEOUT for a long enough period */
3464 exp = tick_add(res->last_valid, resolvers->hold.timeout);
3465 if (!tick_is_expired(exp, now_ms))
3466 return 1;
3467 break;
3468
3469 case RSLV_STATUS_REFUSED:
3470 /* stop server if resolution is REFUSED for a long enough period */
3471 exp = tick_add(res->last_valid, resolvers->hold.refused);
3472 if (!tick_is_expired(exp, now_ms))
3473 return 1;
3474 break;
3475
3476 default:
3477 /* stop server if resolution failed for a long enough period */
3478 exp = tick_add(res->last_valid, resolvers->hold.other);
3479 if (!tick_is_expired(exp, now_ms))
3480 return 1;
3481 }
3482
3483 /* Remove any associated server */
3484 for (s = srvrq->proxy->srv; s != NULL; s = s->next) {
3485 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
3486 if (s->srvrq == srvrq) {
Christopher Faulet0efc0992021-03-11 18:09:53 +01003487 resolv_unlink_resolution(s->resolv_requester, 1);
Christopher Faulet6b117ae2021-03-11 18:06:23 +01003488 srvrq_update_srv_status(s, 1);
Christopher Faulet52d4d302021-02-23 12:24:09 +01003489 memset(&s->addr, 0, sizeof(s->addr));
Christopher Fauletc392d462021-03-10 15:51:13 +01003490 ha_free(&s->hostname);
3491 ha_free(&s->hostname_dn);
3492 s->hostname_dn_len = 0;
Christopher Faulet52d4d302021-02-23 12:24:09 +01003493 s->svc_port = 0;
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003494 }
3495 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
3496 }
3497
Christopher Faulet51d5e3b2021-03-10 15:46:46 +01003498 resolv_purge_resolution_answer_records(res);
3499
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003500 return 1;
3501}
3502
3503/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003504 * Server Name Resolution error management callback
3505 * returns:
3506 * 0 on error
3507 * 1 when no error or safe ignore
Willy Tarreau46b7f532018-08-21 11:54:26 +02003508 *
3509 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003510 */
Emeric Brun08622d32020-12-23 17:41:43 +01003511int snr_resolution_error_cb(struct resolv_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003512{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003513 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003514
Christopher Faulet67957bd2017-09-27 11:00:59 +02003515 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003516 if (!s)
3517 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003518 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Christopher Faulet5130c212021-03-10 20:31:40 +01003519 if (!snr_update_srv_status(s, 1))
3520 memset(&s->addr, 0, sizeof(s->addr));
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003521 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003522 return 1;
3523}
3524
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003525/*
3526 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003527 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003528 * It returns a pointer to the first server found or NULL if <ip> is not yet
3529 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003530 *
3531 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003532 */
3533struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3534{
3535 struct server *tmpsrv;
3536 struct proxy *be;
3537
3538 if (!srv)
3539 return NULL;
3540
3541 be = srv->proxy;
3542 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003543 /* we found the current server is the same, ignore it */
3544 if (srv == tmpsrv)
3545 continue;
3546
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003547 /* We want to compare the IP in the record with the IP of the servers in the
3548 * same backend, only if:
3549 * * DNS resolution is enabled on the server
3550 * * the hostname used for the resolution by our server is the same than the
3551 * one used for the server found in the backend
3552 * * the server found in the backend is not our current server
3553 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003554 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003555 if ((tmpsrv->hostname_dn == NULL) ||
3556 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
Christopher Faulet59b29252021-03-16 11:21:04 +01003557 (strcasecmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01003558 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003559 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003560 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003561 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003562
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003563 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01003564 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003565 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003566 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003567 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003568
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003569 /* At this point, we have 2 different servers using the same DNS hostname
3570 * for their respective resolution.
3571 */
3572 if (*ip_family == tmpsrv->addr.ss_family &&
3573 ((tmpsrv->addr.ss_family == AF_INET &&
3574 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3575 (tmpsrv->addr.ss_family == AF_INET6 &&
3576 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003577 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003578 return tmpsrv;
3579 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003580 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003581 }
3582
Emeric Brune9fd6b52017-11-02 17:20:39 +01003583
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003584 return NULL;
3585}
3586
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003587/* Sets the server's address (srv->addr) from srv->hostname using the libc's
3588 * resolver. This is suited for initial address configuration. Returns 0 on
3589 * success otherwise a non-zero error code. In case of error, *err_code, if
3590 * not NULL, is filled up.
3591 */
3592int srv_set_addr_via_libc(struct server *srv, int *err_code)
3593{
3594 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003595 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01003596 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003597 return 1;
3598 }
3599 return 0;
3600}
3601
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003602/* Set the server's FDQN (->hostname) from <hostname>.
3603 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003604 *
3605 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003606 */
Emeric Brun08622d32020-12-23 17:41:43 +01003607int srv_set_fqdn(struct server *srv, const char *hostname, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003608{
Emeric Brun08622d32020-12-23 17:41:43 +01003609 struct resolv_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003610 char *hostname_dn;
3611 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003612
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02003613 /* Note that the server lock is already held. */
3614 if (!srv->resolvers)
3615 return -1;
3616
Emeric Brun08622d32020-12-23 17:41:43 +01003617 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003618 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003619 /* run time DNS/SRV resolution was not active for this server
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003620 * and we can't enable it at run time for now.
3621 */
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003622 if (!srv->resolv_requester && !srv->srvrq)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003623 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003624
3625 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003626 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003627 hostname_dn = trash.area;
Emeric Brund30e9a12020-12-23 18:49:16 +01003628 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len + 1,
3629 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003630 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003631 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003632
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003633 resolution = (srv->resolv_requester ? srv->resolv_requester->resolution : NULL);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003634 if (resolution &&
3635 resolution->hostname_dn &&
Christopher Faulet59b29252021-03-16 11:21:04 +01003636 resolution->hostname_dn_len == hostname_dn_len &&
3637 strcasecmp(resolution->hostname_dn, hostname_dn) == 0)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003638 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003639
Christopher Faulet0efc0992021-03-11 18:09:53 +01003640 resolv_unlink_resolution(srv->resolv_requester, 0);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003641
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003642 free(srv->hostname);
3643 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003644 srv->hostname = strdup(hostname);
3645 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003646 srv->hostname_dn_len = hostname_dn_len;
3647 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003648 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003649
Baptiste Assmann13a92322019-06-07 09:40:55 +02003650 if (srv->flags & SRV_F_NO_RESOLUTION)
3651 goto end;
3652
Emeric Brund30e9a12020-12-23 18:49:16 +01003653 if (resolv_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003654 goto err;
3655
3656 end:
Emeric Brun08622d32020-12-23 17:41:43 +01003657 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003658 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003659 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02003660
3661 err:
Emeric Brun08622d32020-12-23 17:41:43 +01003662 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003663 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02003664 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003665}
3666
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003667/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
3668 * from the state file. This is suited for initial address configuration.
3669 * Returns 0 on success otherwise a non-zero error code. In case of error,
3670 * *err_code, if not NULL, is filled up.
3671 */
3672static int srv_apply_lastaddr(struct server *srv, int *err_code)
3673{
3674 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
3675 if (err_code)
3676 *err_code |= ERR_WARN;
3677 return 1;
3678 }
3679 return 0;
3680}
3681
Willy Tarreau25e51522016-11-04 15:10:17 +01003682/* returns 0 if no error, otherwise a combination of ERR_* flags */
3683static int srv_iterate_initaddr(struct server *srv)
3684{
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003685 char *name = srv->hostname;
Willy Tarreau25e51522016-11-04 15:10:17 +01003686 int return_code = 0;
3687 int err_code;
3688 unsigned int methods;
3689
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003690 /* If no addr and no hostname set, get the name from the DNS SRV request */
3691 if (!name && srv->srvrq)
3692 name = srv->srvrq->name;
3693
Willy Tarreau25e51522016-11-04 15:10:17 +01003694 methods = srv->init_addr_methods;
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003695 if (!methods) {
3696 /* otherwise default to "last,libc" */
Willy Tarreau25e51522016-11-04 15:10:17 +01003697 srv_append_initaddr(&methods, SRV_IADDR_LAST);
3698 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003699 if (srv->resolvers_id) {
3700 /* dns resolution is configured, add "none" to not fail on startup */
3701 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3702 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003703 }
3704
Willy Tarreau3eed10e2016-11-07 21:03:16 +01003705 /* "-dr" : always append "none" so that server addresses resolution
3706 * failures are silently ignored, this is convenient to validate some
3707 * configs out of their environment.
3708 */
3709 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
3710 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3711
Willy Tarreau25e51522016-11-04 15:10:17 +01003712 while (methods) {
3713 err_code = 0;
3714 switch (srv_get_next_initaddr(&methods)) {
3715 case SRV_IADDR_LAST:
3716 if (!srv->lastaddr)
3717 continue;
3718 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003719 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003720 return_code |= err_code;
3721 break;
3722
3723 case SRV_IADDR_LIBC:
3724 if (!srv->hostname)
3725 continue;
3726 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003727 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003728 return_code |= err_code;
3729 break;
3730
Willy Tarreau37ebe122016-11-04 15:17:58 +01003731 case SRV_IADDR_NONE:
3732 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003733 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003734 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003735 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003736 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01003737 return return_code;
3738
Willy Tarreau4310d362016-11-02 15:05:56 +01003739 case SRV_IADDR_IP:
3740 ipcpy(&srv->init_addr, &srv->addr);
3741 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003742 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 +01003743 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau4310d362016-11-02 15:05:56 +01003744 }
Olivier Houchard4e694042017-03-14 20:01:29 +01003745 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01003746
Willy Tarreau25e51522016-11-04 15:10:17 +01003747 default: /* unhandled method */
3748 break;
3749 }
3750 }
3751
3752 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003753 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003754 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau25e51522016-11-04 15:10:17 +01003755 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01003756 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003757 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003758 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003759 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003760
3761 return_code |= ERR_ALERT | ERR_FATAL;
3762 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01003763out:
3764 srv_set_dyncookie(srv);
Thayne McCombs92149f92020-11-20 01:28:26 -07003765 srv_set_addr_desc(srv);
Olivier Houchard4e694042017-03-14 20:01:29 +01003766 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01003767}
3768
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003769/*
3770 * This function parses all backends and all servers within each backend
3771 * and performs servers' addr resolution based on information provided by:
3772 * - configuration file
3773 * - server-state file (states provided by an 'old' haproxy process)
3774 *
3775 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
3776 */
3777int srv_init_addr(void)
3778{
3779 struct proxy *curproxy;
3780 int return_code = 0;
3781
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003782 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003783 while (curproxy) {
3784 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003785
3786 /* servers are in backend only */
Amaury Denoyellee3c41922021-01-06 14:28:50 +01003787 if (!(curproxy->cap & PR_CAP_BE) || curproxy->disabled)
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003788 goto srv_init_addr_next;
3789
Willy Tarreau25e51522016-11-04 15:10:17 +01003790 for (srv = curproxy->srv; srv; srv = srv->next)
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003791 if (srv->hostname || srv->srvrq)
Willy Tarreau3d609a72017-09-06 14:22:45 +02003792 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003793
3794 srv_init_addr_next:
3795 curproxy = curproxy->next;
3796 }
3797
3798 return return_code;
3799}
3800
Willy Tarreau46b7f532018-08-21 11:54:26 +02003801/*
3802 * Must be called with the server lock held.
3803 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003804const char *srv_update_fqdn(struct server *server, const char *fqdn, const char *updater, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003805{
3806
Willy Tarreau83061a82018-07-13 11:56:34 +02003807 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003808
3809 msg = get_trash_chunk();
3810 chunk_reset(msg);
3811
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003812 if (server->hostname && strcmp(fqdn, server->hostname) == 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003813 chunk_appendf(msg, "no need to change the FDQN");
3814 goto out;
3815 }
3816
3817 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
3818 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
3819 goto out;
3820 }
3821
3822 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
3823 server->proxy->id, server->id, server->hostname, fqdn);
3824
Emeric Brun08622d32020-12-23 17:41:43 +01003825 if (srv_set_fqdn(server, fqdn, resolv_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003826 chunk_reset(msg);
3827 chunk_appendf(msg, "could not update %s/%s FQDN",
3828 server->proxy->id, server->id);
3829 goto out;
3830 }
3831
3832 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02003833 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003834
3835 out:
3836 if (updater)
3837 chunk_appendf(msg, " by '%s'", updater);
3838 chunk_appendf(msg, "\n");
3839
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003840 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003841}
3842
3843
Willy Tarreau21b069d2016-11-23 17:15:08 +01003844/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
3845 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01003846 * 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 +01003847 * used for CLI commands requiring a server name.
3848 * Important: the <arg> is modified to remove the '/'.
3849 */
3850struct server *cli_find_server(struct appctx *appctx, char *arg)
3851{
3852 struct proxy *px;
3853 struct server *sv;
3854 char *line;
3855
3856 /* split "backend/server" and make <line> point to server */
3857 for (line = arg; *line; line++)
3858 if (*line == '/') {
3859 *line++ = '\0';
3860 break;
3861 }
3862
3863 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003864 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003865 return NULL;
3866 }
3867
3868 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003869 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003870 return NULL;
3871 }
3872
Willy Tarreauc3914d42020-09-24 08:39:22 +02003873 if (px->disabled) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003874 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003875 return NULL;
3876 }
3877
3878 return sv;
3879}
3880
William Lallemand222baf22016-11-19 02:00:33 +01003881
Willy Tarreau46b7f532018-08-21 11:54:26 +02003882/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003883static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01003884{
3885 struct server *sv;
3886 const char *warning;
3887
3888 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3889 return 1;
3890
3891 sv = cli_find_server(appctx, args[2]);
3892 if (!sv)
3893 return 1;
3894
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003895 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02003896
William Lallemand222baf22016-11-19 02:00:33 +01003897 if (strcmp(args[3], "weight") == 0) {
3898 warning = server_parse_weight_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02003899 if (warning)
3900 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01003901 }
3902 else if (strcmp(args[3], "state") == 0) {
3903 if (strcmp(args[4], "ready") == 0)
3904 srv_adm_set_ready(sv);
3905 else if (strcmp(args[4], "drain") == 0)
3906 srv_adm_set_drain(sv);
3907 else if (strcmp(args[4], "maint") == 0)
3908 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02003909 else
3910 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003911 }
3912 else if (strcmp(args[3], "health") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003913 if (sv->track)
3914 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003915 else if (strcmp(args[4], "up") == 0) {
3916 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003917 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003918 }
3919 else if (strcmp(args[4], "stopping") == 0) {
3920 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003921 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003922 }
3923 else if (strcmp(args[4], "down") == 0) {
3924 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02003925 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003926 }
Willy Tarreau9d008692019-08-09 11:21:01 +02003927 else
3928 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003929 }
3930 else if (strcmp(args[3], "agent") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003931 if (!(sv->agent.state & CHK_ST_ENABLED))
3932 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003933 else if (strcmp(args[4], "up") == 0) {
3934 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003935 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003936 }
3937 else if (strcmp(args[4], "down") == 0) {
3938 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02003939 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003940 }
Willy Tarreau9d008692019-08-09 11:21:01 +02003941 else
3942 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003943 }
Misiek2da082d2017-01-09 09:40:42 +01003944 else if (strcmp(args[3], "agent-addr") == 0) {
William Dauchy7cabc062021-02-11 22:51:24 +01003945 char *addr = NULL;
3946 char *port = NULL;
3947 if (strlen(args[4]) == 0) {
3948 cli_err(appctx, "set server <b>/<s> agent-addr requires"
3949 " an address and optionally a port.\n");
3950 goto out_unlock;
3951 }
3952 addr = args[4];
3953 if (strcmp(args[5], "port") == 0)
3954 port = args[6];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003955 warning = srv_update_agent_addr_port(sv, addr, port);
William Dauchy7cabc062021-02-11 22:51:24 +01003956 if (warning)
3957 cli_msg(appctx, LOG_WARNING, warning);
3958 }
3959 else if (strcmp(args[3], "agent-port") == 0) {
3960 char *port = NULL;
3961 if (strlen(args[4]) == 0) {
3962 cli_err(appctx, "set server <b>/<s> agent-port requires"
3963 " a port.\n");
3964 goto out_unlock;
3965 }
3966 port = args[4];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003967 warning = srv_update_agent_addr_port(sv, NULL, port);
William Dauchy7cabc062021-02-11 22:51:24 +01003968 if (warning)
3969 cli_msg(appctx, LOG_WARNING, warning);
Misiek2da082d2017-01-09 09:40:42 +01003970 }
3971 else if (strcmp(args[3], "agent-send") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003972 if (!(sv->agent.state & CHK_ST_ENABLED))
3973 cli_err(appctx, "agent checks are not enabled on this server.\n");
3974 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02003975 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02003976 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01003977 }
3978 }
William Dauchyb456e1f2021-02-11 22:51:23 +01003979 else if (strcmp(args[3], "check-addr") == 0) {
3980 char *addr = NULL;
3981 char *port = NULL;
3982 if (strlen(args[4]) == 0) {
3983 cli_err(appctx, "set server <b>/<s> check-addr requires"
3984 " an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003985 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01003986 }
William Dauchyb456e1f2021-02-11 22:51:23 +01003987 addr = args[4];
3988 if (strcmp(args[5], "port") == 0)
3989 port = args[6];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003990 warning = srv_update_check_addr_port(sv, addr, port);
William Dauchyb456e1f2021-02-11 22:51:23 +01003991 if (warning)
3992 cli_msg(appctx, LOG_WARNING, warning);
3993 }
3994 else if (strcmp(args[3], "check-port") == 0) {
3995 char *port = NULL;
3996 if (strlen(args[4]) == 0) {
3997 cli_err(appctx, "set server <b>/<s> check-port requires"
3998 " a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003999 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004000 }
William Dauchyb456e1f2021-02-11 22:51:23 +01004001 port = args[4];
Christopher Faulet69beaa92021-02-16 12:07:47 +01004002 warning = srv_update_check_addr_port(sv, NULL, port);
William Dauchyb456e1f2021-02-11 22:51:23 +01004003 if (warning)
4004 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004005 }
4006 else if (strcmp(args[3], "addr") == 0) {
4007 char *addr = NULL;
4008 char *port = NULL;
4009 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004010 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004011 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004012 }
4013 else {
4014 addr = args[4];
4015 }
4016 if (strcmp(args[5], "port") == 0) {
4017 port = args[6];
4018 }
Christopher Faulet69beaa92021-02-16 12:07:47 +01004019 warning = srv_update_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02004020 if (warning)
4021 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004022 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
4023 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004024 else if (strcmp(args[3], "fqdn") == 0) {
4025 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004026 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004027 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004028 }
Baptiste Assmann13a92322019-06-07 09:40:55 +02004029 /* ensure runtime resolver will process this new fqdn */
4030 if (sv->flags & SRV_F_NO_RESOLUTION) {
4031 sv->flags &= ~SRV_F_NO_RESOLUTION;
4032 }
Christopher Faulet69beaa92021-02-16 12:07:47 +01004033 warning = srv_update_fqdn(sv, args[4], "stats socket command", 0);
Willy Tarreau9d008692019-08-09 11:21:01 +02004034 if (warning)
4035 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004036 }
William Dauchyf6370442020-11-14 19:25:33 +01004037 else if (strcmp(args[3], "ssl") == 0) {
4038#ifdef USE_OPENSSL
4039 if (sv->ssl_ctx.ctx == NULL) {
4040 cli_err(appctx, "'set server <srv> ssl' cannot be set. "
4041 " default-server should define ssl settings\n");
4042 goto out_unlock;
4043 } else if (strcmp(args[4], "on") == 0) {
4044 ssl_sock_set_srv(sv, 1);
4045 } else if (strcmp(args[4], "off") == 0) {
4046 ssl_sock_set_srv(sv, 0);
4047 } else {
4048 cli_err(appctx, "'set server <srv> ssl' expects 'on' or 'off'.\n");
4049 goto out_unlock;
4050 }
4051 srv_cleanup_connections(sv);
4052 cli_msg(appctx, LOG_NOTICE, "server ssl setting updated.\n");
4053#else
4054 cli_msg(appctx, LOG_NOTICE, "server ssl setting not supported.\n");
4055#endif
4056 } else {
Willy Tarreau9d008692019-08-09 11:21:01 +02004057 cli_err(appctx,
William Dauchy3f4ec7d2021-02-15 17:22:16 +01004058 "usage: set server <backend>/<server> "
4059 "addr | agent | agent-addr | agent-port | agent-send | "
4060 "check-addr | check-port | fqdn | health | ssl | "
4061 "state | weight\n");
William Lallemand222baf22016-11-19 02:00:33 +01004062 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004063 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004064 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004065 return 1;
4066}
4067
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004068static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004069{
4070 struct stream_interface *si = appctx->owner;
4071 struct proxy *px;
4072 struct server *sv;
4073 char *line;
4074
4075
4076 /* split "backend/server" and make <line> point to server */
4077 for (line = args[2]; *line; line++)
4078 if (*line == '/') {
4079 *line++ = '\0';
4080 break;
4081 }
4082
Willy Tarreau9d008692019-08-09 11:21:01 +02004083 if (!*line)
4084 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004085
Willy Tarreau9d008692019-08-09 11:21:01 +02004086 if (!get_backend_server(args[2], line, &px, &sv))
4087 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004088
4089 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004090 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
4091 sv->iweight);
4092 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004093 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004094 return 0;
4095 }
William Lallemand6b160942016-11-22 12:34:35 +01004096 return 1;
4097}
4098
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004099/* Parse a "set weight" command.
4100 *
4101 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004102 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004103static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004104{
4105 struct server *sv;
4106 const char *warning;
4107
4108 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4109 return 1;
4110
4111 sv = cli_find_server(appctx, args[2]);
4112 if (!sv)
4113 return 1;
4114
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004115 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4116
William Lallemand6b160942016-11-22 12:34:35 +01004117 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004118 if (warning)
4119 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004120
4121 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4122
William Lallemand6b160942016-11-22 12:34:35 +01004123 return 1;
4124}
4125
Willy Tarreau46b7f532018-08-21 11:54:26 +02004126/* parse a "set maxconn server" command. It always returns 1.
4127 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004128 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004129 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004130static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01004131{
4132 struct server *sv;
4133 const char *warning;
4134
4135 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4136 return 1;
4137
4138 sv = cli_find_server(appctx, args[3]);
4139 if (!sv)
4140 return 1;
4141
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004142 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4143
Willy Tarreaub8026272016-11-23 11:26:56 +01004144 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004145 if (warning)
4146 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004147
4148 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4149
Willy Tarreaub8026272016-11-23 11:26:56 +01004150 return 1;
4151}
William Lallemand6b160942016-11-22 12:34:35 +01004152
Willy Tarreau46b7f532018-08-21 11:54:26 +02004153/* parse a "disable agent" command. It always returns 1.
4154 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004155 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004156 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004157static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004158{
4159 struct server *sv;
4160
4161 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4162 return 1;
4163
4164 sv = cli_find_server(appctx, args[2]);
4165 if (!sv)
4166 return 1;
4167
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004168 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004169 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004170 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004171 return 1;
4172}
4173
Willy Tarreau46b7f532018-08-21 11:54:26 +02004174/* parse a "disable health" command. It always returns 1.
4175 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004176 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004177 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004178static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004179{
4180 struct server *sv;
4181
4182 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4183 return 1;
4184
4185 sv = cli_find_server(appctx, args[2]);
4186 if (!sv)
4187 return 1;
4188
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004189 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004190 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004191 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004192 return 1;
4193}
4194
Willy Tarreau46b7f532018-08-21 11:54:26 +02004195/* parse a "disable server" command. It always returns 1.
4196 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004197 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004198 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004199static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004200{
4201 struct server *sv;
4202
4203 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4204 return 1;
4205
4206 sv = cli_find_server(appctx, args[2]);
4207 if (!sv)
4208 return 1;
4209
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004210 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004211 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004212 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004213 return 1;
4214}
4215
Willy Tarreau46b7f532018-08-21 11:54:26 +02004216/* parse a "enable agent" command. It always returns 1.
4217 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004218 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004219 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004220static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004221{
4222 struct server *sv;
4223
4224 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4225 return 1;
4226
4227 sv = cli_find_server(appctx, args[2]);
4228 if (!sv)
4229 return 1;
4230
Willy Tarreau9d008692019-08-09 11:21:01 +02004231 if (!(sv->agent.state & CHK_ST_CONFIGURED))
4232 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004233
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004234 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004235 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004236 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004237 return 1;
4238}
4239
Willy Tarreau46b7f532018-08-21 11:54:26 +02004240/* parse a "enable health" command. It always returns 1.
4241 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004242 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004243 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004244static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004245{
4246 struct server *sv;
4247
4248 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4249 return 1;
4250
4251 sv = cli_find_server(appctx, args[2]);
4252 if (!sv)
4253 return 1;
4254
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004255 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004256 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004257 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004258 return 1;
4259}
4260
Willy Tarreau46b7f532018-08-21 11:54:26 +02004261/* parse a "enable server" command. It always returns 1.
4262 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004263 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004264 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004265static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004266{
4267 struct server *sv;
4268
4269 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4270 return 1;
4271
4272 sv = cli_find_server(appctx, args[2]);
4273 if (!sv)
4274 return 1;
4275
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004276 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004277 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004278 if (!(sv->flags & SRV_F_COOKIESET)
4279 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4280 sv->cookie)
4281 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004282 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004283 return 1;
4284}
4285
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004286/* Allocates data structure related to load balancing for the server <sv>. It
4287 * is only required for dynamic servers.
4288 *
4289 * At the moment, the server lock is not used as this function is only called
4290 * for a dynamic server not yet registered.
4291 *
4292 * Returns 1 on success, 0 on allocation failure.
4293 */
4294static int srv_alloc_lb(struct server *sv, struct proxy *be)
4295{
4296 int node;
4297
4298 sv->lb_tree = (sv->flags & SRV_F_BACKUP) ?
4299 &be->lbprm.chash.bck : &be->lbprm.chash.act;
4300 sv->lb_nodes_tot = sv->uweight * BE_WEIGHT_SCALE;
4301 sv->lb_nodes_now = 0;
4302
Willy Tarreaudcb121f2021-04-20 11:37:45 +02004303 if (((be->lbprm.algo & (BE_LB_KIND | BE_LB_PARM)) == (BE_LB_KIND_RR | BE_LB_RR_RANDOM)) ||
4304 ((be->lbprm.algo & (BE_LB_KIND | BE_LB_HASH_TYPE)) == (BE_LB_KIND_HI | BE_LB_HASH_CONS))) {
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004305 sv->lb_nodes = calloc(sv->lb_nodes_tot, sizeof(*sv->lb_nodes));
4306
4307 if (!sv->lb_nodes)
4308 return 0;
4309
4310 for (node = 0; node < sv->lb_nodes_tot; node++) {
4311 sv->lb_nodes[node].server = sv;
4312 sv->lb_nodes[node].node.key = full_hash(sv->puid * SRV_EWGHT_RANGE + node);
4313 }
4314 }
4315
4316 return 1;
4317}
4318
4319/* Parse a "add server" command
4320 * Returns 0 if the server has been successfully initialized, 1 on failure.
4321 */
4322static int cli_parse_add_server(char **args, char *payload, struct appctx *appctx, void *private)
4323{
4324 struct proxy *be;
4325 struct server *srv;
4326 char *be_name, *sv_name;
4327 char *errmsg = NULL;
4328 int errcode, argc;
4329 int i;
4330 const int parse_flags = SRV_PARSE_DYNAMIC|SRV_PARSE_PARSE_ADDR;
4331
4332 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4333 return 1;
4334
4335 ++args;
4336
4337 sv_name = be_name = args[1];
4338 /* split backend/server arg */
4339 while (*sv_name && *(++sv_name)) {
4340 if (*sv_name == '/') {
4341 *sv_name = '\0';
4342 ++sv_name;
4343 break;
4344 }
4345 }
4346
4347 if (!*sv_name)
4348 return cli_err(appctx, "Require 'backend/server'.");
4349
Amaury Denoyellecece9182021-04-20 17:09:08 +02004350 be = proxy_be_by_name(be_name);
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004351 if (!be)
4352 return cli_err(appctx, "No such backend.");
4353
4354 if (!(be->lbprm.algo & BE_LB_PROP_DYN)) {
Amaury Denoyelleeafd7012021-04-29 14:59:42 +02004355 cli_err(appctx, "Backend must use a dynamic load balancing to support dynamic servers.");
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004356 return 1;
4357 }
4358
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004359 args[1] = sv_name;
4360 errcode = _srv_parse_init(&srv, args, &argc, be, parse_flags, &errmsg);
4361 if (errcode) {
4362 if (errmsg)
4363 cli_dynerr(appctx, errmsg);
4364 goto out;
4365 }
4366
4367 while (*args[argc]) {
4368 errcode = _srv_parse_kw(srv, args, &argc, be, parse_flags, &errmsg);
4369
4370 if (errcode) {
4371 if (errmsg)
4372 cli_dynerr(appctx, errmsg);
4373 goto out;
4374 }
4375 }
4376
4377 _srv_parse_finalize(args, argc, srv, be, parse_flags, &errmsg);
4378 if (errmsg) {
4379 cli_dynerr(appctx, errmsg);
4380 goto out;
4381 }
4382
Amaury Denoyelle30467232021-03-12 18:03:27 +01004383 if (srv->mux_proto) {
4384 if (!conn_get_best_mux_entry(srv->mux_proto->token, PROTO_SIDE_BE, be->mode)) {
4385 cli_err(appctx, "MUX protocol is not usable for server.");
4386 goto out;
4387 }
4388 }
4389
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004390 srv->per_thr = calloc(global.nbthread, sizeof(*srv->per_thr));
4391 if (!srv->per_thr) {
4392 cli_err(appctx, "failed to allocate per-thread lists for server.");
4393 goto out;
4394 }
4395
4396 for (i = 0; i < global.nbthread; i++) {
4397 srv->per_thr[i].idle_conns = EB_ROOT;
4398 srv->per_thr[i].safe_conns = EB_ROOT;
4399 srv->per_thr[i].avail_conns = EB_ROOT;
4400 MT_LIST_INIT(&srv->per_thr[i].streams);
4401 }
4402
4403 if (srv->max_idle_conns != 0) {
4404 srv->curr_idle_thr = calloc(global.nbthread, sizeof(*srv->curr_idle_thr));
4405 if (!srv->curr_idle_thr) {
4406 cli_err(appctx, "failed to allocate counters for server.");
4407 goto out;
4408 }
4409 }
4410
4411 if (!srv_alloc_lb(srv, be)) {
4412 cli_err(appctx, "Failed to initialize load-balancing data.");
4413 goto out;
4414 }
4415
4416 if (!stats_allocate_proxy_counters_internal(&srv->extra_counters,
4417 COUNTERS_SV,
4418 STATS_PX_CAP_SRV)) {
4419 cli_err(appctx, "failed to allocate extra counters for server.");
4420 goto out;
4421 }
4422
Amaury Denoyellecece9182021-04-20 17:09:08 +02004423 /* Attach the server to the end of the proxy linked list. The proxy
4424 * servers list is currently not protected by a lock, so this requires
4425 * thread_isolate/release.
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004426 *
Amaury Denoyellecece9182021-04-20 17:09:08 +02004427 * If a server with the same name is found, reject the new one. This
4428 * operation requires thread-safety and thus cannot be executed at the
4429 * beginning without having server allocation under locks/isolation.
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004430 */
4431 thread_isolate();
Amaury Denoyellecece9182021-04-20 17:09:08 +02004432
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004433 /* TODO use a double-linked list for px->srv */
4434 if (be->srv) {
Amaury Denoyellecece9182021-04-20 17:09:08 +02004435 struct server *next = be->srv;
4436
4437 while (1) {
4438 /* check for duplicate server */
4439 if (!strcmp(srv->id, next->id)) {
4440 thread_release();
4441 cli_err(appctx, "Already exists a server with the same name in backend.");
4442 goto out;
4443 }
4444
4445 if (!next->next)
4446 break;
4447
4448 next = next->next;
4449 }
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004450
4451 next->next = srv;
4452 }
4453 else {
4454 srv->next = be->srv;
4455 be->srv = srv;
4456 }
Amaury Denoyellecece9182021-04-20 17:09:08 +02004457
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004458 thread_release();
4459
Amaury Denoyelled38e7fa2021-04-20 18:35:19 +02004460 ha_notice("New server %s/%s registered.\n", be->id, srv->id);
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004461 cli_msg(appctx, LOG_INFO, "New server registered.");
4462
4463 return 0;
4464
4465out:
4466 if (srv)
4467 free_server(srv);
4468 return 1;
4469}
4470
Amaury Denoyellee5580432021-04-15 14:41:20 +02004471/* Parse a "del server" command
4472 * Returns 0 if the server has been successfully initialized, 1 on failure.
4473 */
4474static int cli_parse_delete_server(char **args, char *payload, struct appctx *appctx, void *private)
4475{
4476 struct proxy *be;
4477 struct server *srv;
4478 char *be_name, *sv_name;
4479
4480 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4481 return 1;
4482
4483 ++args;
4484
4485 sv_name = be_name = args[1];
4486 /* split backend/server arg */
4487 while (*sv_name && *(++sv_name)) {
4488 if (*sv_name == '/') {
4489 *sv_name = '\0';
4490 ++sv_name;
4491 break;
4492 }
4493 }
4494
4495 if (!*sv_name)
4496 return cli_err(appctx, "Require 'backend/server'.");
4497
4498 /* The proxy servers list is currently not protected by a lock so this
4499 * requires thread isolation.
4500 */
4501
4502 /* WARNING there is maybe a potential violation of the thread isolation
4503 * mechanism by the pool allocator. The allocator marks the thread as
4504 * harmless before the allocation, but a processing outside of it could
4505 * relies on a particular server triggered at the same time by a
4506 * 'delete server'. Currently, it is unknown if such case is present in
4507 * the current code. If it happens to be, the thread isolation
4508 * mechanism should be improved, maybe with a differentiation between
4509 * read and read+write safe sections.
4510 */
4511 thread_isolate();
4512
4513 get_backend_server(be_name, sv_name, &be, &srv);
4514 if (!be) {
4515 cli_err(appctx, "No such backend.");
4516 goto out;
4517 }
4518
4519 if (!srv) {
4520 cli_err(appctx, "No such server.");
4521 goto out;
4522 }
4523
4524 if (!(srv->flags & SRV_F_DYNAMIC)) {
4525 cli_err(appctx, "Only servers added at runtime via <add server> CLI cmd can be deleted.");
4526 goto out;
4527 }
4528
4529 /* Only servers in maintenance can be deleted. This ensures that the
4530 * server is not present anymore in the lb structures (through
4531 * lbprm.set_server_status_down).
4532 */
4533 if (!(srv->cur_admin & SRV_ADMF_MAINT)) {
4534 cli_err(appctx, "Only servers in maintenance mode can be deleted.");
4535 goto out;
4536 }
4537
4538 /* Ensure that there is no active/idle/pending connection on the server.
4539 *
4540 * TODO idle connections should not prevent server deletion. A proper
4541 * cleanup function should be implemented to be used here.
4542 */
4543 if (srv->cur_sess || srv->curr_idle_conns ||
4544 !eb_is_empty(&srv->pendconns)) {
4545 cli_err(appctx, "Server still has connections attached to it, cannot remove it.");
4546 goto out;
4547 }
4548
4549 /* TODO remove server for check list once 'check' will be implemented for
4550 * dynamic servers
4551 */
4552
4553 /* detach the server from the proxy linked list
4554 * The proxy servers list is currently not protected by a lock, so this
4555 * requires thread_isolate/release.
4556 */
4557
4558 /* be->srv cannot be empty since we have already found the server with
4559 * get_backend_server */
4560 BUG_ON(!be->srv);
4561 if (be->srv == srv) {
4562 be->srv = srv->next;
4563 }
4564 else {
4565 struct server *next;
Amaury Denoyelled6b4b6d2021-04-21 11:50:26 +02004566 for (next = be->srv; srv != next->next; next = next->next) {
4567 /* srv cannot be not found since we have already found
4568 * it with get_backend_server */
4569 BUG_ON(!next);
4570 }
Amaury Denoyellee5580432021-04-15 14:41:20 +02004571
Amaury Denoyellee5580432021-04-15 14:41:20 +02004572 next->next = srv->next;
4573 }
4574
4575 /* remove srv from addr_node tree */
4576 ebpt_delete(&srv->addr_node);
4577
4578 /* remove srv from idle_node tree for idle conn cleanup */
4579 eb32_delete(&srv->idle_node);
4580
4581 thread_release();
4582
4583 ha_notice("Server %s/%s deleted.\n", be->id, srv->id);
4584 free_server(srv);
4585
4586 cli_msg(appctx, LOG_INFO, "Server deleted.");
4587
4588 return 0;
4589
4590out:
4591 thread_release();
4592
4593 return 1;
4594}
4595
William Lallemand222baf22016-11-19 02:00:33 +01004596/* register cli keywords */
4597static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004598 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004599 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004600 { { "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 +01004601 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004602 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004603 { { "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 +01004604 { { "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 +01004605 { { "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 +01004606 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4607 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
Amaury Denoyellef99f77a2021-03-08 17:13:32 +01004608 { { "add", "server", NULL }, "add server : create a new server (EXPERIMENTAL)", cli_parse_add_server, NULL, NULL, NULL, ACCESS_EXPERIMENTAL },
Amaury Denoyellee5580432021-04-15 14:41:20 +02004609 { { "del", "server", NULL }, "del server : remove a dynamically added server (EXPERIMENTAL)", cli_parse_delete_server, NULL, NULL, NULL, ACCESS_EXPERIMENTAL },
William Lallemand6b160942016-11-22 12:34:35 +01004610
William Lallemand222baf22016-11-19 02:00:33 +01004611 {{},}
4612}};
4613
Willy Tarreau0108d902018-11-25 19:14:37 +01004614INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004615
Emeric Brun64cc49c2017-10-03 14:46:45 +02004616/*
4617 * This function applies server's status changes, it is
4618 * is designed to be called asynchronously.
4619 *
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004620 * Must be called with the server lock held. This may also be called at init
4621 * time as the result of parsing the state file, in which case no lock will be
4622 * held, and the server's warmup task can be null.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004623 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004624static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004625{
4626 struct check *check = &s->check;
4627 int xferred;
4628 struct proxy *px = s->proxy;
4629 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4630 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4631 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004632 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004633
Emeric Brun64cc49c2017-10-03 14:46:45 +02004634 /* If currently main is not set we try to apply pending state changes */
4635 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4636 int next_admin;
4637
4638 /* Backup next admin */
4639 next_admin = s->next_admin;
4640
4641 /* restore current admin state */
4642 s->next_admin = s->cur_admin;
4643
4644 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4645 s->last_change = now.tv_sec;
4646 if (s->proxy->lbprm.set_server_status_down)
4647 s->proxy->lbprm.set_server_status_down(s);
4648
4649 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4650 srv_shutdown_streams(s, SF_ERR_DOWN);
4651
4652 /* we might have streams queued on this server and waiting for
4653 * a connection. Those which are redispatchable will be queued
4654 * to another server or to the proxy itself.
4655 */
4656 xferred = pendconn_redistribute(s);
4657
4658 tmptrash = alloc_trash_chunk();
4659 if (tmptrash) {
4660 chunk_printf(tmptrash,
4661 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4662 s->proxy->id, s->id);
4663
Emeric Brun5a133512017-10-19 14:42:30 +02004664 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004665 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004666
4667 /* we don't send an alert if the server was previously paused */
4668 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004669 send_log(s->proxy, log_level, "%s.\n",
4670 tmptrash->area);
4671 send_email_alert(s, log_level, "%s",
4672 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004673 free_trash_chunk(tmptrash);
4674 tmptrash = NULL;
4675 }
4676 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4677 set_backend_down(s->proxy);
4678
4679 s->counters.down_trans++;
4680 }
4681 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4682 s->last_change = now.tv_sec;
4683 if (s->proxy->lbprm.set_server_status_down)
4684 s->proxy->lbprm.set_server_status_down(s);
4685
4686 /* we might have streams queued on this server and waiting for
4687 * a connection. Those which are redispatchable will be queued
4688 * to another server or to the proxy itself.
4689 */
4690 xferred = pendconn_redistribute(s);
4691
4692 tmptrash = alloc_trash_chunk();
4693 if (tmptrash) {
4694 chunk_printf(tmptrash,
4695 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4696 s->proxy->id, s->id);
4697
Emeric Brun5a133512017-10-19 14:42:30 +02004698 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004699
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004700 ha_warning("%s.\n", tmptrash->area);
4701 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4702 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004703 free_trash_chunk(tmptrash);
4704 tmptrash = NULL;
4705 }
4706
4707 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4708 set_backend_down(s->proxy);
4709 }
4710 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4711 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4712 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4713 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4714 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4715 s->proxy->last_change = now.tv_sec;
4716 }
4717
Amaury Denoyellefe2bf092020-10-29 15:59:04 +01004718 if (s->cur_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
Emeric Brun64cc49c2017-10-03 14:46:45 +02004719 s->down_time += now.tv_sec - s->last_change;
4720
4721 s->last_change = now.tv_sec;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004722 if (s->next_state == SRV_ST_STARTING && s->warmup)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004723 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4724
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004725 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004726 /* now propagate the status change to any LB algorithms */
4727 if (px->lbprm.update_server_eweight)
4728 px->lbprm.update_server_eweight(s);
4729 else if (srv_willbe_usable(s)) {
4730 if (px->lbprm.set_server_status_up)
4731 px->lbprm.set_server_status_up(s);
4732 }
4733 else {
4734 if (px->lbprm.set_server_status_down)
4735 px->lbprm.set_server_status_down(s);
4736 }
4737
4738 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4739 * and it's not a backup server and its effective weight is > 0,
4740 * then it can accept new connections, so we shut down all streams
4741 * on all backup servers.
4742 */
4743 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4744 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4745 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4746
4747 /* check if we can handle some connections queued at the proxy. We
4748 * will take as many as we can handle.
4749 */
4750 xferred = pendconn_grab_from_px(s);
4751
4752 tmptrash = alloc_trash_chunk();
4753 if (tmptrash) {
4754 chunk_printf(tmptrash,
4755 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4756 s->proxy->id, s->id);
4757
Emeric Brun5a133512017-10-19 14:42:30 +02004758 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004759 ha_warning("%s.\n", tmptrash->area);
4760 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4761 tmptrash->area);
4762 send_email_alert(s, LOG_NOTICE, "%s",
4763 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004764 free_trash_chunk(tmptrash);
4765 tmptrash = NULL;
4766 }
4767
4768 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4769 set_backend_down(s->proxy);
4770 }
4771 else if (s->cur_eweight != s->next_eweight) {
4772 /* now propagate the status change to any LB algorithms */
4773 if (px->lbprm.update_server_eweight)
4774 px->lbprm.update_server_eweight(s);
4775 else if (srv_willbe_usable(s)) {
4776 if (px->lbprm.set_server_status_up)
4777 px->lbprm.set_server_status_up(s);
4778 }
4779 else {
4780 if (px->lbprm.set_server_status_down)
4781 px->lbprm.set_server_status_down(s);
4782 }
4783
4784 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4785 set_backend_down(s->proxy);
4786 }
4787
4788 s->next_admin = next_admin;
4789 }
4790
Emeric Brun5a133512017-10-19 14:42:30 +02004791 /* reset operational state change */
4792 *s->op_st_chg.reason = 0;
4793 s->op_st_chg.status = s->op_st_chg.code = -1;
4794 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004795
4796 /* Now we try to apply pending admin changes */
4797
4798 /* Maintenance must also disable health checks */
4799 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4800 if (s->check.state & CHK_ST_ENABLED) {
4801 s->check.state |= CHK_ST_PAUSED;
4802 check->health = 0;
4803 }
4804
4805 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004806 tmptrash = alloc_trash_chunk();
4807 if (tmptrash) {
4808 chunk_printf(tmptrash,
4809 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4810 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4811 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004812
Olivier Houchard796a2b32017-10-24 17:42:47 +02004813 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004814
Olivier Houchard796a2b32017-10-24 17:42:47 +02004815 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004816 ha_warning("%s.\n", tmptrash->area);
4817 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4818 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004819 }
4820 free_trash_chunk(tmptrash);
4821 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004822 }
Emeric Brun8f298292017-12-06 16:47:17 +01004823 /* commit new admin status */
4824
4825 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004826 }
4827 else { /* server was still running */
4828 check->health = 0; /* failure */
4829 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004830
4831 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004832 if (s->proxy->lbprm.set_server_status_down)
4833 s->proxy->lbprm.set_server_status_down(s);
4834
Emeric Brun64cc49c2017-10-03 14:46:45 +02004835 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4836 srv_shutdown_streams(s, SF_ERR_DOWN);
4837
William Dauchy6318d332020-05-02 21:52:36 +02004838 /* force connection cleanup on the given server */
4839 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004840 /* we might have streams queued on this server and waiting for
4841 * a connection. Those which are redispatchable will be queued
4842 * to another server or to the proxy itself.
4843 */
4844 xferred = pendconn_redistribute(s);
4845
4846 tmptrash = alloc_trash_chunk();
4847 if (tmptrash) {
4848 chunk_printf(tmptrash,
4849 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
4850 s->flags & SRV_F_BACKUP ? "Backup " : "",
4851 s->proxy->id, s->id,
4852 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4853
4854 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
4855
4856 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004857 ha_warning("%s.\n", tmptrash->area);
4858 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
4859 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004860 }
4861 free_trash_chunk(tmptrash);
4862 tmptrash = NULL;
4863 }
4864 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4865 set_backend_down(s->proxy);
4866
4867 s->counters.down_trans++;
4868 }
4869 }
4870 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
4871 /* OK here we're leaving maintenance, we have many things to check,
4872 * because the server might possibly be coming back up depending on
4873 * its state. In practice, leaving maintenance means that we should
4874 * immediately turn to UP (more or less the slowstart) under the
4875 * following conditions :
4876 * - server is neither checked nor tracked
4877 * - server tracks another server which is not checked
4878 * - server tracks another server which is already up
4879 * Which sums up as something simpler :
4880 * "either the tracking server is up or the server's checks are disabled
4881 * or up". Otherwise we only re-enable health checks. There's a special
4882 * case associated to the stopping state which can be inherited. Note
4883 * that the server might still be in drain mode, which is naturally dealt
4884 * with by the lower level functions.
4885 */
4886
4887 if (s->check.state & CHK_ST_ENABLED) {
4888 s->check.state &= ~CHK_ST_PAUSED;
4889 check->health = check->rise; /* start OK but check immediately */
4890 }
4891
4892 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
4893 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
4894 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
4895 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
4896 s->next_state = SRV_ST_STOPPING;
4897 }
4898 else {
4899 s->next_state = SRV_ST_STARTING;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004900 if (s->slowstart > 0) {
4901 if (s->warmup)
4902 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4903 }
Emeric Brun64cc49c2017-10-03 14:46:45 +02004904 else
4905 s->next_state = SRV_ST_RUNNING;
4906 }
4907
4908 }
4909
4910 tmptrash = alloc_trash_chunk();
4911 if (tmptrash) {
4912 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4913 chunk_printf(tmptrash,
4914 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
4915 s->flags & SRV_F_BACKUP ? "Backup " : "",
4916 s->proxy->id, s->id,
4917 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4918 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4919 }
4920 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4921 chunk_printf(tmptrash,
4922 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
4923 s->flags & SRV_F_BACKUP ? "Backup " : "",
4924 s->proxy->id, s->id, s->hostname,
4925 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4926 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4927 }
4928 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4929 chunk_printf(tmptrash,
4930 "%sServer %s/%s is %s/%s (leaving maintenance)",
4931 s->flags & SRV_F_BACKUP ? "Backup " : "",
4932 s->proxy->id, s->id,
4933 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4934 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4935 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004936 ha_warning("%s.\n", tmptrash->area);
4937 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4938 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004939 free_trash_chunk(tmptrash);
4940 tmptrash = NULL;
4941 }
4942
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004943 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004944 /* now propagate the status change to any LB algorithms */
4945 if (px->lbprm.update_server_eweight)
4946 px->lbprm.update_server_eweight(s);
4947 else if (srv_willbe_usable(s)) {
4948 if (px->lbprm.set_server_status_up)
4949 px->lbprm.set_server_status_up(s);
4950 }
4951 else {
4952 if (px->lbprm.set_server_status_down)
4953 px->lbprm.set_server_status_down(s);
4954 }
4955
4956 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4957 set_backend_down(s->proxy);
4958
Willy Tarreau6a78e612018-08-07 10:14:53 +02004959 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4960 * and it's not a backup server and its effective weight is > 0,
4961 * then it can accept new connections, so we shut down all streams
4962 * on all backup servers.
4963 */
4964 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4965 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4966 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4967
4968 /* check if we can handle some connections queued at the proxy. We
4969 * will take as many as we can handle.
4970 */
4971 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004972 }
4973 else if (s->next_admin & SRV_ADMF_MAINT) {
4974 /* remaining in maintenance mode, let's inform precisely about the
4975 * situation.
4976 */
4977 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4978 tmptrash = alloc_trash_chunk();
4979 if (tmptrash) {
4980 chunk_printf(tmptrash,
4981 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
4982 s->flags & SRV_F_BACKUP ? "Backup " : "",
4983 s->proxy->id, s->id);
4984
4985 if (s->track) /* normally it's mandatory here */
4986 chunk_appendf(tmptrash, " via %s/%s",
4987 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004988 ha_warning("%s.\n", tmptrash->area);
4989 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4990 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004991 free_trash_chunk(tmptrash);
4992 tmptrash = NULL;
4993 }
4994 }
4995 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4996 tmptrash = alloc_trash_chunk();
4997 if (tmptrash) {
4998 chunk_printf(tmptrash,
4999 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
5000 s->flags & SRV_F_BACKUP ? "Backup " : "",
5001 s->proxy->id, s->id, s->hostname);
5002
5003 if (s->track) /* normally it's mandatory here */
5004 chunk_appendf(tmptrash, " via %s/%s",
5005 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005006 ha_warning("%s.\n", tmptrash->area);
5007 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5008 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005009 free_trash_chunk(tmptrash);
5010 tmptrash = NULL;
5011 }
5012 }
5013 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5014 tmptrash = alloc_trash_chunk();
5015 if (tmptrash) {
5016 chunk_printf(tmptrash,
5017 "%sServer %s/%s remains in forced maintenance",
5018 s->flags & SRV_F_BACKUP ? "Backup " : "",
5019 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005020 ha_warning("%s.\n", tmptrash->area);
5021 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5022 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005023 free_trash_chunk(tmptrash);
5024 tmptrash = NULL;
5025 }
5026 }
5027 /* don't report anything when leaving drain mode and remaining in maintenance */
5028
5029 s->cur_admin = s->next_admin;
5030 }
5031
5032 if (!(s->next_admin & SRV_ADMF_MAINT)) {
5033 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
5034 /* drain state is applied only if not yet in maint */
5035
5036 s->last_change = now.tv_sec;
5037 if (px->lbprm.set_server_status_down)
5038 px->lbprm.set_server_status_down(s);
5039
5040 /* we might have streams queued on this server and waiting for
5041 * a connection. Those which are redispatchable will be queued
5042 * to another server or to the proxy itself.
5043 */
5044 xferred = pendconn_redistribute(s);
5045
5046 tmptrash = alloc_trash_chunk();
5047 if (tmptrash) {
5048 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
5049 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5050 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5051
5052 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
5053
5054 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005055 ha_warning("%s.\n", tmptrash->area);
5056 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5057 tmptrash->area);
5058 send_email_alert(s, LOG_NOTICE, "%s",
5059 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005060 }
5061 free_trash_chunk(tmptrash);
5062 tmptrash = NULL;
5063 }
5064
5065 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5066 set_backend_down(s->proxy);
5067 }
5068 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
5069 /* OK completely leaving drain mode */
5070 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
5071 if (s->proxy->last_change < now.tv_sec) // ignore negative times
5072 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
5073 s->proxy->last_change = now.tv_sec;
5074 }
5075
5076 if (s->last_change < now.tv_sec) // ignore negative times
5077 s->down_time += now.tv_sec - s->last_change;
5078 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005079 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005080
5081 tmptrash = alloc_trash_chunk();
5082 if (tmptrash) {
5083 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5084 chunk_printf(tmptrash,
5085 "%sServer %s/%s is %s (leaving forced drain)",
5086 s->flags & SRV_F_BACKUP ? "Backup " : "",
5087 s->proxy->id, s->id,
5088 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5089 }
5090 else {
5091 chunk_printf(tmptrash,
5092 "%sServer %s/%s is %s (leaving drain)",
5093 s->flags & SRV_F_BACKUP ? "Backup " : "",
5094 s->proxy->id, s->id,
5095 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5096 if (s->track) /* normally it's mandatory here */
5097 chunk_appendf(tmptrash, " via %s/%s",
5098 s->track->proxy->id, s->track->id);
5099 }
5100
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005101 ha_warning("%s.\n", tmptrash->area);
5102 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5103 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005104 free_trash_chunk(tmptrash);
5105 tmptrash = NULL;
5106 }
5107
5108 /* now propagate the status change to any LB algorithms */
5109 if (px->lbprm.update_server_eweight)
5110 px->lbprm.update_server_eweight(s);
5111 else if (srv_willbe_usable(s)) {
5112 if (px->lbprm.set_server_status_up)
5113 px->lbprm.set_server_status_up(s);
5114 }
5115 else {
5116 if (px->lbprm.set_server_status_down)
5117 px->lbprm.set_server_status_down(s);
5118 }
5119 }
5120 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
5121 /* remaining in drain mode after removing one of its flags */
5122
5123 tmptrash = alloc_trash_chunk();
5124 if (tmptrash) {
5125 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5126 chunk_printf(tmptrash,
5127 "%sServer %s/%s is leaving forced drain but remains in drain mode",
5128 s->flags & SRV_F_BACKUP ? "Backup " : "",
5129 s->proxy->id, s->id);
5130
5131 if (s->track) /* normally it's mandatory here */
5132 chunk_appendf(tmptrash, " via %s/%s",
5133 s->track->proxy->id, s->track->id);
5134 }
5135 else {
5136 chunk_printf(tmptrash,
5137 "%sServer %s/%s remains in forced drain mode",
5138 s->flags & SRV_F_BACKUP ? "Backup " : "",
5139 s->proxy->id, s->id);
5140 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005141 ha_warning("%s.\n", tmptrash->area);
5142 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5143 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005144 free_trash_chunk(tmptrash);
5145 tmptrash = NULL;
5146 }
5147
5148 /* commit new admin status */
5149
5150 s->cur_admin = s->next_admin;
5151 }
5152 }
5153
5154 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02005155 *s->adm_st_chg_cause = 0;
5156}
Emeric Brun64cc49c2017-10-03 14:46:45 +02005157
Willy Tarreau144f84a2021-03-02 16:09:26 +01005158struct task *srv_cleanup_toremove_conns(struct task *task, void *context, unsigned int state)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005159{
5160 struct connection *conn;
5161
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005162 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005163 struct connection *, toremove_list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02005164 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005165 }
5166
5167 return task;
5168}
5169
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005170/* Move toremove_nb connections from idle_tree to toremove_list, -1 means
Olivier Houchardff1d0922020-06-29 20:15:59 +02005171 * moving them all.
5172 * Returns the number of connections moved.
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005173 *
5174 * Must be called with idle_conns_lock held.
Olivier Houchardff1d0922020-06-29 20:15:59 +02005175 */
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005176static int srv_migrate_conns_to_remove(struct eb_root *idle_tree, struct mt_list *toremove_list, int toremove_nb)
Olivier Houchardff1d0922020-06-29 20:15:59 +02005177{
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005178 struct eb_node *node, *next;
Amaury Denoyelle8990b012021-02-19 15:29:16 +01005179 struct conn_hash_node *hash_node;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005180 int i = 0;
5181
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005182 node = eb_first(idle_tree);
5183 while (node) {
5184 next = eb_next(node);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005185 if (toremove_nb != -1 && i >= toremove_nb)
5186 break;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005187
Amaury Denoyelle8990b012021-02-19 15:29:16 +01005188 hash_node = ebmb_entry(node, struct conn_hash_node, node);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005189 eb_delete(node);
Willy Tarreau2b718102021-04-21 07:32:39 +02005190 MT_LIST_APPEND(toremove_list, &hash_node->conn->toremove_list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005191 i++;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01005192
5193 node = next;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005194 }
5195 return i;
5196}
William Dauchy6318d332020-05-02 21:52:36 +02005197/* cleanup connections for a given server
5198 * might be useful when going on forced maintenance or live changing ip/port
5199 */
William Dauchy707ad322020-05-04 13:52:40 +02005200static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02005201{
William Dauchy6318d332020-05-02 21:52:36 +02005202 int did_remove;
5203 int i;
William Dauchy6318d332020-05-02 21:52:36 +02005204
Amaury Denoyelle10d5c312021-01-06 14:28:51 +01005205 /* nothing to do if pool-max-conn is null */
5206 if (!srv->max_idle_conns)
5207 return;
5208
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005209 /* check all threads starting with ours */
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005210 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02005211 did_remove = 0;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005212 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005213 if (srv_migrate_conns_to_remove(&srv->per_thr[i].idle_conns, &idle_conns[i].toremove_conns, -1) > 0)
William Dauchy6318d332020-05-02 21:52:36 +02005214 did_remove = 1;
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005215 if (srv_migrate_conns_to_remove(&srv->per_thr[i].safe_conns, &idle_conns[i].toremove_conns, -1) > 0)
Olivier Houchardff1d0922020-06-29 20:15:59 +02005216 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005217 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
William Dauchy6318d332020-05-02 21:52:36 +02005218 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005219 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005220
5221 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5222 break;
William Dauchy6318d332020-05-02 21:52:36 +02005223 }
William Dauchy6318d332020-05-02 21:52:36 +02005224}
5225
Willy Tarreau144f84a2021-03-02 16:09:26 +01005226struct task *srv_cleanup_idle_conns(struct task *task, void *context, unsigned int state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005227{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005228 struct server *srv;
5229 struct eb32_node *eb;
5230 int i;
5231 unsigned int next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005232
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005233 next_wakeup = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005234 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
5235 while (1) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005236 int exceed_conns;
5237 int to_kill;
5238 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005239
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005240 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
5241 if (!eb) {
5242 /* we might have reached the end of the tree, typically because
5243 * <now_ms> is in the first half and we're first scanning the last
5244 * half. Let's loop back to the beginning of the tree now.
5245 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005246
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005247 eb = eb32_first(&idle_conn_srv);
5248 if (likely(!eb))
5249 break;
5250 }
5251 if (tick_is_lt(now_ms, eb->key)) {
5252 /* timer not expired yet, revisit it later */
5253 next_wakeup = eb->key;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005254 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005255 }
5256 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005257
5258 /* Calculate how many idle connections we want to kill :
5259 * we want to remove half the difference between the total
5260 * of established connections (used or idle) and the max
5261 * number of used connections.
5262 */
5263 curr_idle = srv->curr_idle_conns;
5264 if (curr_idle == 0)
5265 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005266 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005267 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005268
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005269 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns) / 2;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005270 if (srv->est_need_conns < srv->max_used_conns)
5271 srv->est_need_conns = srv->max_used_conns;
5272
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005273 srv->max_used_conns = srv->curr_used_conns;
5274
Willy Tarreau18ed7892020-07-02 19:05:30 +02005275 if (exceed_conns <= 0)
5276 goto remove;
5277
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005278 /* check all threads starting with ours */
5279 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005280 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005281 int j;
5282 int did_remove = 0;
5283
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005284 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
5285 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005286
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005287 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005288 j = srv_migrate_conns_to_remove(&srv->per_thr[i].idle_conns, &idle_conns[i].toremove_conns, max_conn);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005289 if (j > 0)
5290 did_remove = 1;
5291 if (max_conn - j > 0 &&
Willy Tarreau430bf4a2021-03-04 09:45:32 +01005292 srv_migrate_conns_to_remove(&srv->per_thr[i].safe_conns, &idle_conns[i].toremove_conns, max_conn - j) > 0)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005293 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01005294 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005295
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005296 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005297 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005298
5299 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5300 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005301 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005302remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005303 eb32_delete(&srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005304
5305 if (srv->curr_idle_conns) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005306 /* There are still more idle connections, add the
5307 * server back in the tree.
5308 */
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005309 srv->idle_node.key = tick_add(srv->pool_purge_delay, now_ms);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005310 eb32_insert(&idle_conn_srv, &srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005311 next_wakeup = tick_first(next_wakeup, srv->idle_node.key);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005312 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005313 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005314 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5315
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005316 task->expire = next_wakeup;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005317 return task;
5318}
Olivier Houchard88698d92019-04-16 19:07:22 +02005319
Amaury Denoyelle3109ccf2021-04-29 17:30:05 +02005320/* Close remaining idle connections. This functions is designed to be run on
5321 * process shutdown. This guarantees a proper socket shutdown to avoid
5322 * TIME_WAIT state. For a quick operation, only ctrl is closed, xprt stack is
5323 * bypassed.
5324 *
5325 * This function is not thread-safe so it must only be called via a global
5326 * deinit function.
5327 */
5328static void srv_close_idle_conns(struct server *srv)
5329{
5330 struct eb_root **cleaned_tree;
5331 int i;
5332
5333 for (i = 0; i < global.nbthread; ++i) {
5334 struct eb_root *conn_trees[] = {
5335 &srv->per_thr[i].idle_conns,
5336 &srv->per_thr[i].safe_conns,
5337 &srv->per_thr[i].avail_conns,
5338 NULL
5339 };
5340
5341 for (cleaned_tree = conn_trees; *cleaned_tree; ++cleaned_tree) {
5342 while (!eb_is_empty(*cleaned_tree)) {
5343 struct ebmb_node *node = ebmb_first(*cleaned_tree);
5344 struct conn_hash_node *conn_hash_node = ebmb_entry(node, struct conn_hash_node, node);
5345 struct connection *conn = conn_hash_node->conn;
5346
5347 if (conn->ctrl->ctrl_close)
5348 conn->ctrl->ctrl_close(conn);
5349 ebmb_delete(node);
5350 }
5351 }
5352 }
5353}
5354
5355REGISTER_SERVER_DEINIT(srv_close_idle_conns);
5356
Willy Tarreau76cc6992020-07-01 18:49:24 +02005357/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
5358static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01005359 const struct proxy *defpx, const char *file, int line,
Willy Tarreau76cc6992020-07-01 18:49:24 +02005360 char **err)
5361{
5362 if (too_many_args(1, args, err, NULL))
5363 return -1;
5364
5365 if (strcmp(args[1], "on") == 0)
5366 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
5367 else if (strcmp(args[1], "off") == 0)
5368 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
5369 else {
5370 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
5371 return -1;
5372 }
5373 return 0;
5374}
5375
Olivier Houchard88698d92019-04-16 19:07:22 +02005376/* config parser for global "tune.pool-{low,high}-fd-ratio" */
5377static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01005378 const struct proxy *defpx, const char *file, int line,
Olivier Houchard88698d92019-04-16 19:07:22 +02005379 char **err)
5380{
5381 int arg = -1;
5382
5383 if (too_many_args(1, args, err, NULL))
5384 return -1;
5385
5386 if (*(args[1]) != 0)
5387 arg = atoi(args[1]);
5388
5389 if (arg < 0 || arg > 100) {
5390 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
5391 return -1;
5392 }
5393
5394 if (args[0][10] == 'h')
5395 global.tune.pool_high_ratio = arg;
5396 else
5397 global.tune.pool_low_ratio = arg;
5398 return 0;
5399}
5400
5401/* config keyword parsers */
5402static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02005403 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02005404 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
5405 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
5406 { 0, NULL, NULL }
5407}};
5408
5409INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
5410
Baptiste Assmanna68ca962015-04-14 01:15:08 +02005411/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02005412 * Local variables:
5413 * c-indent-level: 8
5414 * c-basic-offset: 8
5415 * End:
5416 */