blob: 809666fae1c1066c913a16f2d887915c3412e4c7 [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>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020041#include <haproxy/stats-t.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
Willy Tarreau49c2b452021-03-12 09:58:04 +010053/* some keywords that are still being parsed using strcmp() and are not
54 * registered anywhere. They are used as suggestions for mistyped words.
55 */
56static const char *common_kw_list[] = {
57 "init-addr", "resolvers", "resolve-opts", "resolve-prefer", "ipv4",
58 "ipv6", "resolve-net", "weight", "log-proto", "legacy", "octet-count",
59 "minconn", "maxconn", "maxqueue", "slowstart", "on-error", "fastinter",
60 "fail-check", "sudden-death", "mark-down", "on-marked-down",
61 "shutdown-sessions", "on-marked-up", "shutdown-backup-sessions",
62 "error-limit", "usesrc",
63 NULL /* must be last */
64};
65
Willy Tarreau21faa912012-10-10 08:27:36 +020066/* List head of all known server keywords */
67static struct srv_kw_list srv_keywords = {
68 .list = LIST_HEAD_INIT(srv_keywords.list)
69};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020070
Willy Tarreauaf613e82020-06-05 08:40:51 +020071__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010072struct eb_root idle_conn_srv = EB_ROOT;
73struct task *idle_conn_task = NULL;
Willy Tarreau198e92a2021-03-05 10:23:32 +010074struct list servers_list = LIST_HEAD_INIT(servers_list);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010075
Frédéric Lécaille7da71292019-05-20 09:47:07 +020076/* The server names dictionary */
Thayne McCombs92149f92020-11-20 01:28:26 -070077struct dict server_key_dict = {
78 .name = "server keys",
Frédéric Lécaille7da71292019-05-20 09:47:07 +020079 .values = EB_ROOT_UNIQUE,
80};
81
Simon Hormana3608442013-11-01 16:46:15 +090082int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020083{
Amaury Denoyellee6ba7912020-10-29 15:59:05 +010084 if ((s->cur_state != SRV_ST_STOPPED) || s->last_change >= now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020085 return s->down_time;
86
87 return now.tv_sec - s->last_change + s->down_time;
88}
Willy Tarreaubaaee002006-06-26 02:48:02 +020089
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050090int srv_lastsession(const struct server *s)
91{
92 if (s->counters.last_sess)
93 return now.tv_sec - s->counters.last_sess;
94
95 return -1;
96}
97
Simon Horman4a741432013-02-23 15:35:38 +090098int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020099{
Simon Horman4a741432013-02-23 15:35:38 +0900100 const struct server *s = check->server;
101
Willy Tarreauff5ae352013-12-11 20:36:34 +0100102 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +0900103 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100104
Emeric Brun52a91d32017-08-31 14:41:55 +0200105 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +0900106 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100107
Simon Horman4a741432013-02-23 15:35:38 +0900108 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100109}
110
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100111/*
112 * Check that we did not get a hash collision.
Willy Tarreau595e7672020-10-20 17:30:08 +0200113 * Unlikely, but it can happen. The server's proxy must be at least
114 * read-locked.
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100115 */
116static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +0100117{
118 struct proxy *p = s->proxy;
119 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100120
121 for (tmpserv = p->srv; tmpserv != NULL;
122 tmpserv = tmpserv->next) {
123 if (tmpserv == s)
124 continue;
125 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
126 continue;
127 if (tmpserv->cookie &&
128 strcmp(tmpserv->cookie, s->cookie) == 0) {
129 ha_warning("We generated two equal cookies for two different servers.\n"
130 "Please change the secret key for '%s'.\n",
131 s->proxy->id);
132 }
133 }
134
135}
136
Willy Tarreau46b7f532018-08-21 11:54:26 +0200137/*
Willy Tarreau595e7672020-10-20 17:30:08 +0200138 * Must be called with the server lock held, and will read-lock the proxy.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200139 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100140void srv_set_dyncookie(struct server *s)
141{
142 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100143 char *tmpbuf;
144 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100145 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100146 size_t buffer_len;
147 int addr_len;
148 int port;
149
Willy Tarreau595e7672020-10-20 17:30:08 +0200150 HA_RWLOCK_RDLOCK(PROXY_LOCK, &p->lock);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200151
Olivier Houchard4e694042017-03-14 20:01:29 +0100152 if ((s->flags & SRV_F_COOKIESET) ||
153 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
154 s->proxy->dyncookie_key == NULL)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200155 goto out;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100156 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100157
158 if (s->addr.ss_family != AF_INET &&
159 s->addr.ss_family != AF_INET6)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200160 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100161 /*
162 * Buffer to calculate the cookie value.
163 * The buffer contains the secret key + the server IP address
164 * + the TCP port.
165 */
166 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
167 /*
168 * The TCP port should use only 2 bytes, but is stored in
169 * an unsigned int in struct server, so let's use 4, to be
170 * on the safe side.
171 */
172 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200173 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100174 memcpy(tmpbuf, p->dyncookie_key, key_len);
175 memcpy(&(tmpbuf[key_len]),
176 s->addr.ss_family == AF_INET ?
177 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
178 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
179 addr_len);
180 /*
181 * Make sure it's the same across all the load balancers,
182 * no matter their endianness.
183 */
184 port = htonl(s->svc_port);
185 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
186 hash_value = XXH64(tmpbuf, buffer_len, 0);
187 memprintf(&s->cookie, "%016llx", hash_value);
188 if (!s->cookie)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200189 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100190 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100191
192 /* Don't bother checking if the dyncookie is duplicated if
193 * the server is marked as "disabled", maybe it doesn't have
194 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100195 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100196 if (!(s->next_admin & SRV_ADMF_FMAINT))
197 srv_check_for_dup_dyncookie(s);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200198 out:
Willy Tarreau595e7672020-10-20 17:30:08 +0200199 HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &p->lock);
Olivier Houchard4e694042017-03-14 20:01:29 +0100200}
201
Willy Tarreau21faa912012-10-10 08:27:36 +0200202/*
Thayne McCombs92149f92020-11-20 01:28:26 -0700203 * Must be called with the server lock held, and will write-lock the proxy.
204 */
205static void srv_set_addr_desc(struct server *s)
206{
207 struct proxy *p = s->proxy;
208 char *key;
209
210 key = sa2str(&s->addr, s->svc_port, s->flags & SRV_F_MAPPORTS);
211
212 if (s->addr_node.key) {
Thayne McCombs24da7e12021-01-05 23:10:09 -0700213 if (key && strcmp(key, s->addr_node.key) == 0) {
Thayne McCombs92149f92020-11-20 01:28:26 -0700214 free(key);
215 return;
216 }
217
218 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
219 ebpt_delete(&s->addr_node);
220 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
221
222 free(s->addr_node.key);
223 }
224
225 s->addr_node.key = key;
226
Thayne McCombs24da7e12021-01-05 23:10:09 -0700227 if (s->addr_node.key) {
228 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
229 ebis_insert(&p->used_server_addr, &s->addr_node);
230 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
231 }
Thayne McCombs92149f92020-11-20 01:28:26 -0700232}
233
234/*
Willy Tarreau21faa912012-10-10 08:27:36 +0200235 * Registers the server keyword list <kwl> as a list of valid keywords for next
236 * parsing sessions.
237 */
238void srv_register_keywords(struct srv_kw_list *kwl)
239{
240 LIST_ADDQ(&srv_keywords.list, &kwl->list);
241}
242
243/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
244 * keyword is found with a NULL ->parse() function, then an attempt is made to
245 * find one with a valid ->parse() function. This way it is possible to declare
246 * platform-dependant, known keywords as NULL, then only declare them as valid
247 * if some options are met. Note that if the requested keyword contains an
248 * opening parenthesis, everything from this point is ignored.
249 */
250struct srv_kw *srv_find_kw(const char *kw)
251{
252 int index;
253 const char *kwend;
254 struct srv_kw_list *kwl;
255 struct srv_kw *ret = NULL;
256
257 kwend = strchr(kw, '(');
258 if (!kwend)
259 kwend = kw + strlen(kw);
260
261 list_for_each_entry(kwl, &srv_keywords.list, list) {
262 for (index = 0; kwl->kw[index].kw != NULL; index++) {
263 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
264 kwl->kw[index].kw[kwend-kw] == 0) {
265 if (kwl->kw[index].parse)
266 return &kwl->kw[index]; /* found it !*/
267 else
268 ret = &kwl->kw[index]; /* may be OK */
269 }
270 }
271 }
272 return ret;
273}
274
275/* Dumps all registered "server" keywords to the <out> string pointer. The
276 * unsupported keywords are only dumped if their supported form was not
277 * found.
278 */
279void srv_dump_kws(char **out)
280{
281 struct srv_kw_list *kwl;
282 int index;
283
Christopher Faulet784063e2020-05-18 12:14:18 +0200284 if (!out)
285 return;
286
Willy Tarreau21faa912012-10-10 08:27:36 +0200287 *out = NULL;
288 list_for_each_entry(kwl, &srv_keywords.list, list) {
289 for (index = 0; kwl->kw[index].kw != NULL; index++) {
290 if (kwl->kw[index].parse ||
291 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
292 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
293 kwl->scope,
294 kwl->kw[index].kw,
295 kwl->kw[index].skip ? " <arg>" : "",
296 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
297 kwl->kw[index].parse ? "" : " (not supported)");
298 }
299 }
300 }
Willy Tarreau49c2b452021-03-12 09:58:04 +0100301}
302
303/* Try to find in srv_keyword the word that looks closest to <word> by counting
304 * transitions between letters, digits and other characters. Will return the
305 * best matching word if found, otherwise NULL. An optional array of extra
306 * words to compare may be passed in <extra>, but it must then be terminated
307 * by a NULL entry. If unused it may be NULL.
308 */
309static const char *srv_find_best_kw(const char *word)
310{
311 uint8_t word_sig[1024];
312 uint8_t list_sig[1024];
313 const struct srv_kw_list *kwl;
314 const char *best_ptr = NULL;
315 int dist, best_dist = INT_MAX;
316 const char **extra;
317 int index;
318
319 make_word_fingerprint(word_sig, word);
320 list_for_each_entry(kwl, &srv_keywords.list, list) {
321 for (index = 0; kwl->kw[index].kw != NULL; index++) {
322 make_word_fingerprint(list_sig, kwl->kw[index].kw);
323 dist = word_fingerprint_distance(word_sig, list_sig);
324 if (dist < best_dist) {
325 best_dist = dist;
326 best_ptr = kwl->kw[index].kw;
327 }
328 }
329 }
330
331 for (extra = common_kw_list; *extra; extra++) {
332 make_word_fingerprint(list_sig, *extra);
333 dist = word_fingerprint_distance(word_sig, list_sig);
334 if (dist < best_dist) {
335 best_dist = dist;
336 best_ptr = *extra;
337 }
Willy Tarreau49c2b452021-03-12 09:58:04 +0100338 }
339
340 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
341 best_ptr = NULL;
342
343 return best_ptr;
Willy Tarreau21faa912012-10-10 08:27:36 +0200344}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100345
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100346/* Parse the "backup" server keyword */
347static int srv_parse_backup(char **args, int *cur_arg,
348 struct proxy *curproxy, struct server *newsrv, char **err)
349{
350 newsrv->flags |= SRV_F_BACKUP;
351 return 0;
352}
353
Alexander Liu2a54bb72019-05-22 19:44:48 +0800354
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100355/* Parse the "cookie" server keyword */
356static int srv_parse_cookie(char **args, int *cur_arg,
357 struct proxy *curproxy, struct server *newsrv, char **err)
358{
359 char *arg;
360
361 arg = args[*cur_arg + 1];
362 if (!*arg) {
363 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
364 return ERR_ALERT | ERR_FATAL;
365 }
366
367 free(newsrv->cookie);
368 newsrv->cookie = strdup(arg);
369 newsrv->cklen = strlen(arg);
370 newsrv->flags |= SRV_F_COOKIESET;
371 return 0;
372}
373
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100374/* Parse the "disabled" server keyword */
375static int srv_parse_disabled(char **args, int *cur_arg,
376 struct proxy *curproxy, struct server *newsrv, char **err)
377{
Emeric Brun52a91d32017-08-31 14:41:55 +0200378 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
379 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100380 newsrv->check.state |= CHK_ST_PAUSED;
381 newsrv->check.health = 0;
382 return 0;
383}
384
385/* Parse the "enabled" server keyword */
386static int srv_parse_enabled(char **args, int *cur_arg,
387 struct proxy *curproxy, struct server *newsrv, char **err)
388{
Emeric Brun52a91d32017-08-31 14:41:55 +0200389 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
390 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100391 newsrv->check.state &= ~CHK_ST_PAUSED;
392 newsrv->check.health = newsrv->check.rise;
393 return 0;
394}
395
Willy Tarreau9c538e02019-01-23 10:21:49 +0100396static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
397{
398 char *arg;
399
400 arg = args[*cur_arg + 1];
401 if (!*arg) {
402 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
403 return ERR_ALERT | ERR_FATAL;
404 }
405 newsrv->max_reuse = atoi(arg);
406
407 return 0;
408}
409
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100410static 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 +0100411{
412 const char *res;
413 char *arg;
414 unsigned int time;
415
416 arg = args[*cur_arg + 1];
417 if (!*arg) {
418 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
419 return ERR_ALERT | ERR_FATAL;
420 }
421 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200422 if (res == PARSE_TIME_OVER) {
423 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
424 args[*cur_arg+1], args[*cur_arg]);
425 return ERR_ALERT | ERR_FATAL;
426 }
427 else if (res == PARSE_TIME_UNDER) {
428 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
429 args[*cur_arg+1], args[*cur_arg]);
430 return ERR_ALERT | ERR_FATAL;
431 }
432 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100433 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
434 *res, args[*cur_arg]);
435 return ERR_ALERT | ERR_FATAL;
436 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100437 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100438
439 return 0;
440}
441
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200442static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
443{
444 char *arg;
445
446 arg = args[*cur_arg + 1];
447 if (!*arg) {
448 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
449 return ERR_ALERT | ERR_FATAL;
450 }
451
452 newsrv->low_idle_conns = atoi(arg);
453 return 0;
454}
455
Olivier Houchard006e3102018-12-10 18:30:32 +0100456static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
457{
458 char *arg;
459
460 arg = args[*cur_arg + 1];
461 if (!*arg) {
462 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
463 return ERR_ALERT | ERR_FATAL;
464 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100465
Olivier Houchard006e3102018-12-10 18:30:32 +0100466 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100467 if ((int)newsrv->max_idle_conns < -1) {
468 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
469 return ERR_ALERT | ERR_FATAL;
470 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100471
472 return 0;
473}
474
Willy Tarreaudff55432012-10-10 17:51:05 +0200475/* parse the "id" server keyword */
476static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
477{
478 struct eb32_node *node;
479
480 if (!*args[*cur_arg + 1]) {
481 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
482 return ERR_ALERT | ERR_FATAL;
483 }
484
485 newsrv->puid = atol(args[*cur_arg + 1]);
486 newsrv->conf.id.key = newsrv->puid;
487
488 if (newsrv->puid <= 0) {
489 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
490 return ERR_ALERT | ERR_FATAL;
491 }
492
493 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
494 if (node) {
495 struct server *target = container_of(node, struct server, conf.id);
496 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
497 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
498 target->id);
499 return ERR_ALERT | ERR_FATAL;
500 }
501
502 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200503 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200504 return 0;
505}
506
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100507/* Parse the "namespace" server keyword */
508static int srv_parse_namespace(char **args, int *cur_arg,
509 struct proxy *curproxy, struct server *newsrv, char **err)
510{
Willy Tarreaue5733232019-05-22 19:24:06 +0200511#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100512 char *arg;
513
514 arg = args[*cur_arg + 1];
515 if (!*arg) {
516 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
517 return ERR_ALERT | ERR_FATAL;
518 }
519
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100520 if (strcmp(arg, "*") == 0) {
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100521 /* Use the namespace associated with the connection (if present). */
522 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
523 return 0;
524 }
525
526 /*
527 * As this parser may be called several times for the same 'default-server'
528 * object, or for a new 'server' instance deriving from a 'default-server'
529 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
530 */
531 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
532
533 newsrv->netns = netns_store_lookup(arg, strlen(arg));
534 if (!newsrv->netns)
535 newsrv->netns = netns_store_insert(arg);
536
537 if (!newsrv->netns) {
538 memprintf(err, "Cannot open namespace '%s'", arg);
539 return ERR_ALERT | ERR_FATAL;
540 }
541
542 return 0;
543#else
544 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
545 return ERR_ALERT | ERR_FATAL;
546#endif
547}
548
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100549/* Parse the "no-backup" server keyword */
550static int srv_parse_no_backup(char **args, int *cur_arg,
551 struct proxy *curproxy, struct server *newsrv, char **err)
552{
553 newsrv->flags &= ~SRV_F_BACKUP;
554 return 0;
555}
556
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100557
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100558/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200559static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100560{
561 srv->pp_opts &= ~flags;
562 return 0;
563}
564
565/* Parse the "no-send-proxy" server keyword */
566static int srv_parse_no_send_proxy(char **args, int *cur_arg,
567 struct proxy *curproxy, struct server *newsrv, char **err)
568{
569 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
570}
571
572/* Parse the "no-send-proxy-v2" server keyword */
573static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
574 struct proxy *curproxy, struct server *newsrv, char **err)
575{
576 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
577}
578
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200579/* Parse the "no-tfo" server keyword */
580static int srv_parse_no_tfo(char **args, int *cur_arg,
581 struct proxy *curproxy, struct server *newsrv, char **err)
582{
583 newsrv->flags &= ~SRV_F_FASTOPEN;
584 return 0;
585}
586
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100587/* Parse the "non-stick" server keyword */
588static int srv_parse_non_stick(char **args, int *cur_arg,
589 struct proxy *curproxy, struct server *newsrv, char **err)
590{
591 newsrv->flags |= SRV_F_NON_STICK;
592 return 0;
593}
594
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100595/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200596static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100597{
598 srv->pp_opts |= flags;
599 return 0;
600}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200601/* parse the "proto" server keyword */
602static int srv_parse_proto(char **args, int *cur_arg,
603 struct proxy *px, struct server *newsrv, char **err)
604{
605 struct ist proto;
606
607 if (!*args[*cur_arg + 1]) {
608 memprintf(err, "'%s' : missing value", args[*cur_arg]);
609 return ERR_ALERT | ERR_FATAL;
610 }
Tim Duesterhusdcf753a2021-03-04 17:31:47 +0100611 proto = ist(args[*cur_arg + 1]);
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200612 newsrv->mux_proto = get_mux_proto(proto);
613 if (!newsrv->mux_proto) {
614 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
615 return ERR_ALERT | ERR_FATAL;
616 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200617 return 0;
618}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100619
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100620/* parse the "proxy-v2-options" */
621static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
622 struct proxy *px, struct server *newsrv, char **err)
623{
624 char *p, *n;
625 for (p = args[*cur_arg+1]; p; p = n) {
626 n = strchr(p, ',');
627 if (n)
628 *n++ = '\0';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100629 if (strcmp(p, "ssl") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100630 newsrv->pp_opts |= SRV_PP_V2_SSL;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100631 } else if (strcmp(p, "cert-cn") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100632 newsrv->pp_opts |= SRV_PP_V2_SSL;
633 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100634 } else if (strcmp(p, "cert-key") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100635 newsrv->pp_opts |= SRV_PP_V2_SSL;
636 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100637 } else if (strcmp(p, "cert-sig") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100638 newsrv->pp_opts |= SRV_PP_V2_SSL;
639 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100640 } else if (strcmp(p, "ssl-cipher") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100641 newsrv->pp_opts |= SRV_PP_V2_SSL;
642 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100643 } else if (strcmp(p, "authority") == 0) {
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100644 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100645 } else if (strcmp(p, "crc32c") == 0) {
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100646 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100647 } else if (strcmp(p, "unique-id") == 0) {
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100648 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100649 } else
650 goto fail;
651 }
652 return 0;
653 fail:
654 if (err)
655 memprintf(err, "'%s' : proxy v2 option not implemented", p);
656 return ERR_ALERT | ERR_FATAL;
657}
658
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100659/* Parse the "observe" server keyword */
660static int srv_parse_observe(char **args, int *cur_arg,
661 struct proxy *curproxy, struct server *newsrv, char **err)
662{
663 char *arg;
664
665 arg = args[*cur_arg + 1];
666 if (!*arg) {
667 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
668 return ERR_ALERT | ERR_FATAL;
669 }
670
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100671 if (strcmp(arg, "none") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100672 newsrv->observe = HANA_OBS_NONE;
673 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100674 else if (strcmp(arg, "layer4") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100675 newsrv->observe = HANA_OBS_LAYER4;
676 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100677 else if (strcmp(arg, "layer7") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100678 if (curproxy->mode != PR_MODE_HTTP) {
679 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
680 return ERR_ALERT;
681 }
682 newsrv->observe = HANA_OBS_LAYER7;
683 }
684 else {
685 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
686 "but got '%s'\n", args[*cur_arg], arg);
687 return ERR_ALERT | ERR_FATAL;
688 }
689
690 return 0;
691}
692
Frédéric Lécaille16186232017-03-14 16:42:49 +0100693/* Parse the "redir" server keyword */
694static int srv_parse_redir(char **args, int *cur_arg,
695 struct proxy *curproxy, struct server *newsrv, char **err)
696{
697 char *arg;
698
699 arg = args[*cur_arg + 1];
700 if (!*arg) {
701 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
702 return ERR_ALERT | ERR_FATAL;
703 }
704
705 free(newsrv->rdr_pfx);
706 newsrv->rdr_pfx = strdup(arg);
707 newsrv->rdr_len = strlen(arg);
708
709 return 0;
710}
711
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100712/* Parse the "send-proxy" server keyword */
713static int srv_parse_send_proxy(char **args, int *cur_arg,
714 struct proxy *curproxy, struct server *newsrv, char **err)
715{
716 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
717}
718
719/* Parse the "send-proxy-v2" server keyword */
720static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
721 struct proxy *curproxy, struct server *newsrv, char **err)
722{
723 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
724}
725
Frédéric Lécailledba97072017-03-17 15:33:50 +0100726
727/* Parse the "source" server keyword */
728static int srv_parse_source(char **args, int *cur_arg,
729 struct proxy *curproxy, struct server *newsrv, char **err)
730{
731 char *errmsg;
732 int port_low, port_high;
733 struct sockaddr_storage *sk;
Frédéric Lécailledba97072017-03-17 15:33:50 +0100734
735 errmsg = NULL;
736
737 if (!*args[*cur_arg + 1]) {
738 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
739 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
740 goto err;
741 }
742
743 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200744 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
745 &errmsg, NULL, NULL,
746 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 +0100747 if (!sk) {
748 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
749 goto err;
750 }
751
Frédéric Lécailledba97072017-03-17 15:33:50 +0100752 newsrv->conn_src.opts |= CO_SRC_BIND;
753 newsrv->conn_src.source_addr = *sk;
754
755 if (port_low != port_high) {
756 int i;
757
Frédéric Lécailledba97072017-03-17 15:33:50 +0100758 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
759 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
760 newsrv->conn_src.sport_range->ports[i] = port_low + i;
761 }
762
763 *cur_arg += 2;
764 while (*(args[*cur_arg])) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100765 if (strcmp(args[*cur_arg], "usesrc") == 0) { /* address to use outside */
Frédéric Lécailledba97072017-03-17 15:33:50 +0100766#if defined(CONFIG_HAP_TRANSPARENT)
767 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100768 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
769 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100770 goto err;
771 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100772 if (strcmp(args[*cur_arg + 1], "client") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +0100773 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
774 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
775 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100776 else if (strcmp(args[*cur_arg + 1], "clientip") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +0100777 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
778 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
779 }
780 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
781 char *name, *end;
782
783 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +0100784 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100785 name++;
786
787 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +0100788 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +0100789 end++;
790
791 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
792 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
793 free(newsrv->conn_src.bind_hdr_name);
794 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
795 newsrv->conn_src.bind_hdr_len = end - name;
796 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
797 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
798 newsrv->conn_src.bind_hdr_occ = -1;
799
800 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +0100801 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100802 end++;
803 if (*end == ',') {
804 end++;
805 name = end;
806 if (*end == '-')
807 end++;
Willy Tarreau90807112020-02-25 08:16:33 +0100808 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100809 end++;
810 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
811 }
812
813 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100814 ha_alert("usesrc hdr_ip(name,num) does not support negative"
815 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100816 goto err;
817 }
818 }
819 else {
820 struct sockaddr_storage *sk;
821 int port1, port2;
822
823 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200824 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, NULL, NULL,
825 &errmsg, NULL, NULL,
826 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100827 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100828 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100829 goto err;
830 }
831
Frédéric Lécailledba97072017-03-17 15:33:50 +0100832 newsrv->conn_src.tproxy_addr = *sk;
833 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
834 }
835 global.last_checks |= LSTCHK_NETADM;
836 *cur_arg += 2;
837 continue;
838#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100839 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 +0100840 goto err;
841#endif /* defined(CONFIG_HAP_TRANSPARENT) */
842 } /* "usesrc" */
843
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100844 if (strcmp(args[*cur_arg], "interface") == 0) { /* specifically bind to this interface */
Frédéric Lécailledba97072017-03-17 15:33:50 +0100845#ifdef SO_BINDTODEVICE
846 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100847 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100848 goto err;
849 }
850 free(newsrv->conn_src.iface_name);
851 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
852 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
853 global.last_checks |= LSTCHK_NETADM;
854#else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100855 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100856 goto err;
857#endif
858 *cur_arg += 2;
859 continue;
860 }
861 /* this keyword in not an option of "source" */
862 break;
863 } /* while */
864
865 return 0;
866
867 err:
868 free(errmsg);
869 return ERR_ALERT | ERR_FATAL;
870}
871
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100872/* Parse the "stick" server keyword */
873static int srv_parse_stick(char **args, int *cur_arg,
874 struct proxy *curproxy, struct server *newsrv, char **err)
875{
876 newsrv->flags &= ~SRV_F_NON_STICK;
877 return 0;
878}
879
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100880/* Parse the "track" server keyword */
881static int srv_parse_track(char **args, int *cur_arg,
882 struct proxy *curproxy, struct server *newsrv, char **err)
883{
884 char *arg;
885
886 arg = args[*cur_arg + 1];
887 if (!*arg) {
888 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
889 return ERR_ALERT | ERR_FATAL;
890 }
891
892 free(newsrv->trackit);
893 newsrv->trackit = strdup(arg);
894
895 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800896}
897
898/* Parse the "socks4" server keyword */
899static int srv_parse_socks4(char **args, int *cur_arg,
900 struct proxy *curproxy, struct server *newsrv, char **err)
901{
902 char *errmsg;
903 int port_low, port_high;
904 struct sockaddr_storage *sk;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800905
906 errmsg = NULL;
907
908 if (!*args[*cur_arg + 1]) {
909 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
910 goto err;
911 }
912
913 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200914 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
915 &errmsg, NULL, NULL,
916 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_CONNECT);
Alexander Liu2a54bb72019-05-22 19:44:48 +0800917 if (!sk) {
918 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
919 goto err;
920 }
921
Alexander Liu2a54bb72019-05-22 19:44:48 +0800922 newsrv->flags |= SRV_F_SOCKS4_PROXY;
923 newsrv->socks4_addr = *sk;
924
Alexander Liu2a54bb72019-05-22 19:44:48 +0800925 return 0;
926
927 err:
928 free(errmsg);
929 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100930}
931
Frédéric Lécailledba97072017-03-17 15:33:50 +0100932
Willy Tarreau034c88c2017-01-23 23:36:45 +0100933/* parse the "tfo" server keyword */
934static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
935{
936 newsrv->flags |= SRV_F_FASTOPEN;
937 return 0;
938}
939
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200940/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200941 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200942 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200943 *
944 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200945 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200946void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200947{
Willy Tarreau751153e2021-02-17 13:33:24 +0100948 struct stream *stream;
949 struct mt_list *elt1, elt2;
Willy Tarreaud4e78d82021-03-04 10:47:54 +0100950 int thr;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200951
Willy Tarreaud4e78d82021-03-04 10:47:54 +0100952 for (thr = 0; thr < global.nbthread; thr++)
953 mt_list_for_each_entry_safe(stream, &srv->per_thr[thr].streams, by_srv, elt1, elt2)
954 if (stream->srv_conn == srv)
955 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200956}
957
958/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200959 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200960 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200961 *
962 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200963 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200964void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200965{
966 struct server *srv;
967
968 for (srv = px->srv; srv != NULL; srv = srv->next)
969 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200970 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200971}
972
Willy Tarreaubda92272014-05-20 21:55:30 +0200973/* Appends some information to a message string related to a server going UP or
974 * DOWN. If both <forced> and <reason> are null and the server tracks another
975 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +0200976 * If <check> is non-null, an entire string describing the check result will be
977 * appended after a comma and a space (eg: to report some information from the
978 * check that changed the state). In the other case, the string will be built
979 * using the check results stored into the struct server if present.
980 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +0200981 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200982 *
983 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200984 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200985void srv_append_status(struct buffer *msg, struct server *s,
986 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200987{
Emeric Brun5a133512017-10-19 14:42:30 +0200988 short status = s->op_st_chg.status;
989 short code = s->op_st_chg.code;
990 long duration = s->op_st_chg.duration;
991 char *desc = s->op_st_chg.reason;
992
993 if (check) {
994 status = check->status;
995 code = check->code;
996 duration = check->duration;
997 desc = check->desc;
998 }
999
1000 if (status != -1) {
1001 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
1002
1003 if (status >= HCHK_STATUS_L57DATA)
1004 chunk_appendf(msg, ", code: %d", code);
1005
1006 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001007 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +02001008
1009 chunk_appendf(msg, ", info: \"");
1010
1011 chunk_initlen(&src, desc, 0, strlen(desc));
1012 chunk_asciiencode(msg, &src, '"');
1013
1014 chunk_appendf(msg, "\"");
1015 }
1016
1017 if (duration >= 0)
1018 chunk_appendf(msg, ", check duration: %ldms", duration);
1019 }
1020 else if (desc && *desc) {
1021 chunk_appendf(msg, ", %s", desc);
1022 }
1023 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +02001024 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +02001025 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001026
1027 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +02001028 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001029 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
1030 " %d sessions active, %d requeued, %d remaining in queue",
1031 s->proxy->srv_act, s->proxy->srv_bck,
1032 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
1033 s->cur_sess, xferred, s->nbpend);
1034 else
1035 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
1036 " %d sessions requeued, %d total in queue",
1037 s->proxy->srv_act, s->proxy->srv_bck,
1038 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
1039 xferred, s->nbpend);
1040 }
1041}
1042
Emeric Brun5a133512017-10-19 14:42:30 +02001043/* Marks server <s> down, regardless of its checks' statuses. The server is
1044 * registered in a list to postpone the counting of the remaining servers on
1045 * the proxy and transfers queued streams whenever possible to other servers at
1046 * a sync point. Maintenance servers are ignored. It stores the <reason> if
1047 * non-null as the reason for going down or the available data from the check
1048 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001049 *
1050 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001051 */
Emeric Brun5a133512017-10-19 14:42:30 +02001052void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001053{
1054 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001055
Emeric Brun64cc49c2017-10-03 14:46:45 +02001056 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001057 return;
1058
Emeric Brun52a91d32017-08-31 14:41:55 +02001059 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001060 *s->op_st_chg.reason = 0;
1061 s->op_st_chg.status = -1;
1062 if (reason) {
1063 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1064 }
1065 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001066 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001067 s->op_st_chg.code = check->code;
1068 s->op_st_chg.status = check->status;
1069 s->op_st_chg.duration = check->duration;
1070 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001071
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001072 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001073 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001074
Emeric Brun9f0b4582017-10-23 14:39:51 +02001075 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001076 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001077 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001078 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001079 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001080}
1081
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001082/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001083 * in maintenance. The server is registered in a list to postpone the counting
1084 * of the remaining servers on the proxy and tries to grab requests from the
1085 * proxy at a sync point. Maintenance servers are ignored. It stores the
1086 * <reason> if non-null as the reason for going down or the available data
1087 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001088 *
1089 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001090 */
Emeric Brun5a133512017-10-19 14:42:30 +02001091void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001092{
1093 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001094
Emeric Brun64cc49c2017-10-03 14:46:45 +02001095 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001096 return;
1097
Emeric Brun52a91d32017-08-31 14:41:55 +02001098 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001099 return;
1100
Emeric Brun52a91d32017-08-31 14:41:55 +02001101 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001102 *s->op_st_chg.reason = 0;
1103 s->op_st_chg.status = -1;
1104 if (reason) {
1105 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1106 }
1107 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001108 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001109 s->op_st_chg.code = check->code;
1110 s->op_st_chg.status = check->status;
1111 s->op_st_chg.duration = check->duration;
1112 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001113
Emeric Brun64cc49c2017-10-03 14:46:45 +02001114 if (s->slowstart <= 0)
1115 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001116
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001117 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001118 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001119
Emeric Brun9f0b4582017-10-23 14:39:51 +02001120 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001121 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001122 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001123 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001124 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001125}
1126
Willy Tarreau8eb77842014-05-21 13:54:57 +02001127/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001128 * isn't in maintenance. The server is registered in a list to postpone the
1129 * counting of the remaining servers on the proxy and tries to grab requests
1130 * from the proxy. Maintenance servers are ignored. It stores the
1131 * <reason> if non-null as the reason for going down or the available data
1132 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001133 * up. Note that it makes use of the trash to build the log strings, so <reason>
1134 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001135 *
1136 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001137 */
Emeric Brun5a133512017-10-19 14:42:30 +02001138void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001139{
1140 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001141
Emeric Brun64cc49c2017-10-03 14:46:45 +02001142 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001143 return;
1144
Emeric Brun52a91d32017-08-31 14:41:55 +02001145 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001146 return;
1147
Emeric Brun52a91d32017-08-31 14:41:55 +02001148 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001149 *s->op_st_chg.reason = 0;
1150 s->op_st_chg.status = -1;
1151 if (reason) {
1152 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1153 }
1154 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001155 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001156 s->op_st_chg.code = check->code;
1157 s->op_st_chg.status = check->status;
1158 s->op_st_chg.duration = check->duration;
1159 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001160
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001161 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001162 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001163
Emeric Brun9f0b4582017-10-23 14:39:51 +02001164 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001165 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001166 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001167 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001168 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001169}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001170
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001171/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1172 * enforce either maint mode or drain mode. It is not allowed to set more than
1173 * one flag at once. The equivalent "inherited" flag is propagated to all
1174 * tracking servers. Maintenance mode disables health checks (but not agent
1175 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001176 * is done. If <cause> is non-null, it will be displayed at the end of the log
1177 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001178 *
1179 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001180 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001181void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001182{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001183 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001184
1185 if (!mode)
1186 return;
1187
1188 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001189 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001190 return;
1191
Emeric Brun52a91d32017-08-31 14:41:55 +02001192 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001193 if (cause)
1194 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1195
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001196 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001197 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001198
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001199 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001200 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1201 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001202 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001203
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001204 /* compute the inherited flag to propagate */
1205 if (mode & SRV_ADMF_MAINT)
1206 mode = SRV_ADMF_IMAINT;
1207 else if (mode & SRV_ADMF_DRAIN)
1208 mode = SRV_ADMF_IDRAIN;
1209
Emeric Brun9f0b4582017-10-23 14:39:51 +02001210 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001211 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001212 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001213 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001214 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001215}
1216
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001217/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1218 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1219 * than one flag at once. The equivalent "inherited" flag is propagated to all
1220 * tracking servers. Leaving maintenance mode re-enables health checks. When
1221 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001222 *
1223 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001224 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001225void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001226{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001227 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001228
1229 if (!mode)
1230 return;
1231
1232 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001233 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001234 return;
1235
Emeric Brun52a91d32017-08-31 14:41:55 +02001236 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001237
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001238 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001239 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001240
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001241 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001242 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1243 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001244 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001245
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001246 if (mode & SRV_ADMF_MAINT)
1247 mode = SRV_ADMF_IMAINT;
1248 else if (mode & SRV_ADMF_DRAIN)
1249 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001250
Emeric Brun9f0b4582017-10-23 14:39:51 +02001251 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001252 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001253 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001254 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001255 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001256}
1257
Willy Tarreau757478e2016-11-03 19:22:19 +01001258/* principle: propagate maint and drain to tracking servers. This is useful
1259 * upon startup so that inherited states are correct.
1260 */
1261static void srv_propagate_admin_state(struct server *srv)
1262{
1263 struct server *srv2;
1264
1265 if (!srv->trackers)
1266 return;
1267
1268 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001269 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001270 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001271 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001272
Emeric Brun52a91d32017-08-31 14:41:55 +02001273 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001274 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001275 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001276 }
1277}
1278
1279/* Compute and propagate the admin states for all servers in proxy <px>.
1280 * Only servers *not* tracking another one are considered, because other
1281 * ones will be handled when the server they track is visited.
1282 */
1283void srv_compute_all_admin_states(struct proxy *px)
1284{
1285 struct server *srv;
1286
1287 for (srv = px->srv; srv; srv = srv->next) {
1288 if (srv->track)
1289 continue;
1290 srv_propagate_admin_state(srv);
1291 }
1292}
1293
Willy Tarreaudff55432012-10-10 17:51:05 +02001294/* Note: must not be declared <const> as its list will be overwritten.
1295 * Please take care of keeping this list alphabetically sorted, doing so helps
1296 * all code contributors.
1297 * Optional keywords are also declared with a NULL ->parse() function so that
1298 * the config parser can report an appropriate error when a known keyword was
1299 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001300 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001301 */
1302static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001303 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +01001304 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001305 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1306 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001307 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Willy Tarreau9c538e02019-01-23 10:21:49 +01001308 { "max-reuse", srv_parse_max_reuse, 1, 1 }, /* Set the max number of requests on a connection, -1 means unlimited */
Frédéric Lécaille22f41a22017-03-16 17:17:36 +01001309 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001310 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001311 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1312 { "no-send-proxy-v2", srv_parse_no_send_proxy_v2, 0, 1 }, /* Disable use of PROXY V2 protocol */
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +02001313 { "no-tfo", srv_parse_no_tfo, 0, 1 }, /* Disable use of TCP Fast Open */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001314 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001315 { "observe", srv_parse_observe, 1, 1 }, /* Enables health adjusting based on observing communication with the server */
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001316 { "pool-low-conn", srv_parse_pool_low_conn, 1, 1 }, /* Set the min number of orphan idle connecbefore being allowed to pick from other threads */
Amaury Denoyelle18c68df2021-01-26 14:35:24 +01001317 { "pool-max-conn", srv_parse_pool_max_conn, 1, 1 }, /* Set the max number of orphan idle connections, -1 means unlimited */
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001318 { "pool-purge-delay", srv_parse_pool_purge_delay, 1, 1 }, /* Set the time before we destroy orphan idle connections, defaults to 1s */
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001319 { "proto", srv_parse_proto, 1, 1 }, /* Set the proto to use for all outgoing connections */
Emmanuel Hocdetf643b802018-02-01 15:20:32 +01001320 { "proxy-v2-options", srv_parse_proxy_v2_options, 1, 1 }, /* options for send-proxy-v2 */
Frédéric Lécaille16186232017-03-14 16:42:49 +01001321 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001322 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1323 { "send-proxy-v2", srv_parse_send_proxy_v2, 0, 1 }, /* Enforce use of PROXY V2 protocol */
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001324 { "source", srv_parse_source, -1, 1 }, /* Set the source address to be used to connect to the server */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001325 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Olivier Houchard8d82db72019-07-04 13:34:10 +02001326 { "tfo", srv_parse_tfo, 0, 1 }, /* enable TCP Fast Open of server */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001327 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Alexander Liu2a54bb72019-05-22 19:44:48 +08001328 { "socks4", srv_parse_socks4, 1, 1 }, /* Set the socks4 proxy of the server*/
Willy Tarreaudff55432012-10-10 17:51:05 +02001329 { NULL, NULL, 0 },
1330}};
1331
Willy Tarreau0108d902018-11-25 19:14:37 +01001332INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001333
Willy Tarreau004e0452013-11-21 11:22:01 +01001334/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001335 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001336 * state is automatically disabled if the time is elapsed. If <must_update> is
1337 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001338 *
1339 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001340 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001341void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001342{
1343 struct proxy *px = sv->proxy;
1344 unsigned w;
1345
1346 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1347 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001348 if (sv->next_state == SRV_ST_STARTING)
1349 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001350 }
1351
1352 /* We must take care of not pushing the server to full throttle during slow starts.
1353 * It must also start immediately, at least at the minimal step when leaving maintenance.
1354 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001355 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001356 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1357 else
1358 w = px->lbprm.wdiv;
1359
Emeric Brun52a91d32017-08-31 14:41:55 +02001360 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001361
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001362 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001363 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001364 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001365}
1366
Willy Tarreaubaaee002006-06-26 02:48:02 +02001367/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001368 * Parses weight_str and configures sv accordingly.
1369 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001370 *
1371 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001372 */
1373const char *server_parse_weight_change_request(struct server *sv,
1374 const char *weight_str)
1375{
1376 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001377 long int w;
1378 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001379
1380 px = sv->proxy;
1381
1382 /* if the weight is terminated with '%', it is set relative to
1383 * the initial weight, otherwise it is absolute.
1384 */
1385 if (!*weight_str)
1386 return "Require <weight> or <weight%>.\n";
1387
Simon Hormanb796afa2013-02-12 10:45:53 +09001388 w = strtol(weight_str, &end, 10);
1389 if (end == weight_str)
1390 return "Empty weight string empty or preceded by garbage";
1391 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001392 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001393 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001394 /* Avoid integer overflow */
1395 if (w > 25600)
1396 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001397 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001398 if (w > 256)
1399 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001400 }
1401 else if (w < 0 || w > 256)
1402 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001403 else if (end[0] != '\0')
1404 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001405
1406 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1407 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1408
1409 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001410 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001411
1412 return NULL;
1413}
1414
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001415/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001416 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1417 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001418 * Returns:
1419 * - error string on error
1420 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001421 *
1422 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001423 */
1424const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001425 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001426{
1427 unsigned char ip[INET6_ADDRSTRLEN];
1428
1429 if (inet_pton(AF_INET6, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001430 srv_update_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001431 return NULL;
1432 }
1433 if (inet_pton(AF_INET, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001434 srv_update_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001435 return NULL;
1436 }
1437
1438 return "Could not understand IP address format.\n";
1439}
1440
Willy Tarreau46b7f532018-08-21 11:54:26 +02001441/*
1442 * Must be called with the server lock held.
1443 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001444const char *server_parse_maxconn_change_request(struct server *sv,
1445 const char *maxconn_str)
1446{
1447 long int v;
1448 char *end;
1449
1450 if (!*maxconn_str)
1451 return "Require <maxconn>.\n";
1452
1453 v = strtol(maxconn_str, &end, 10);
1454 if (end == maxconn_str)
1455 return "maxconn string empty or preceded by garbage";
1456 else if (end[0] != '\0')
1457 return "Trailing garbage in maxconn string";
1458
1459 if (sv->maxconn == sv->minconn) { // static maxconn
1460 sv->maxconn = sv->minconn = v;
1461 } else { // dynamic maxconn
1462 sv->maxconn = v;
1463 }
1464
1465 if (may_dequeue_tasks(sv, sv->proxy))
1466 process_srv_queue(sv);
1467
1468 return NULL;
1469}
1470
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001471#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001472static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1473 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001474{
1475 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001476 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001477 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001478 NULL,
1479 };
1480
1481 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001482 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001483
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001484 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001485}
1486
1487static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1488{
1489 struct sample_expr *expr;
1490
1491 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 +01001492 if (!expr) {
1493 memprintf(err, "error detected while parsing sni expression : %s", *err);
1494 return ERR_ALERT | ERR_FATAL;
1495 }
1496
1497 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1498 memprintf(err, "error detected while parsing sni expression : "
1499 " fetch method '%s' extracts information from '%s', "
1500 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001501 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001502 return ERR_ALERT | ERR_FATAL;
1503 }
1504
1505 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1506 release_sample_expr(newsrv->ssl_ctx.sni);
1507 newsrv->ssl_ctx.sni = expr;
1508
1509 return 0;
1510}
1511#endif
1512
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001513static 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 +01001514{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001515 char *msg = "error encountered while processing ";
1516 char *quote = "'";
1517 char *token = args[cur_arg];
1518
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001519 if (err && *err) {
1520 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001521 msg = *err;
1522 quote = "";
1523 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001524 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001525
1526 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
1527 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1528 file, linenum, args[0], args[1],
1529 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001530 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001531 ha_alert("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1532 file, linenum, args[0], args[1],
1533 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001534}
1535
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001536static void srv_conn_src_sport_range_cpy(struct server *srv,
1537 struct server *src)
1538{
1539 int range_sz;
1540
1541 range_sz = src->conn_src.sport_range->size;
1542 if (range_sz > 0) {
1543 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1544 if (srv->conn_src.sport_range != NULL) {
1545 int i;
1546
1547 for (i = 0; i < range_sz; i++) {
1548 srv->conn_src.sport_range->ports[i] =
1549 src->conn_src.sport_range->ports[i];
1550 }
1551 }
1552 }
1553}
1554
1555/*
1556 * Copy <src> server connection source settings to <srv> server everything needed.
1557 */
1558static void srv_conn_src_cpy(struct server *srv, struct server *src)
1559{
1560 srv->conn_src.opts = src->conn_src.opts;
1561 srv->conn_src.source_addr = src->conn_src.source_addr;
1562
1563 /* Source port range copy. */
1564 if (src->conn_src.sport_range != NULL)
1565 srv_conn_src_sport_range_cpy(srv, src);
1566
1567#ifdef CONFIG_HAP_TRANSPARENT
1568 if (src->conn_src.bind_hdr_name != NULL) {
1569 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1570 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1571 }
1572 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1573 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1574#endif
1575 if (src->conn_src.iface_name != NULL)
1576 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1577}
1578
1579/*
1580 * Copy <src> server SSL settings to <srv> server allocating
1581 * everything needed.
1582 */
1583#if defined(USE_OPENSSL)
1584static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1585{
1586 if (src->ssl_ctx.ca_file != NULL)
1587 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1588 if (src->ssl_ctx.crl_file != NULL)
1589 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001590
1591 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1592
1593 if (src->ssl_ctx.verify_host != NULL)
1594 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1595 if (src->ssl_ctx.ciphers != NULL)
1596 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02001597 if (src->ssl_ctx.options)
1598 srv->ssl_ctx.options = src->ssl_ctx.options;
1599 if (src->ssl_ctx.methods.flags)
1600 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
1601 if (src->ssl_ctx.methods.min)
1602 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
1603 if (src->ssl_ctx.methods.max)
1604 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
1605
Ilya Shipitsin2aa4b3a2021-01-07 11:55:45 +05001606#ifdef HAVE_SSL_CTX_SET_CIPHERSUITES
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001607 if (src->ssl_ctx.ciphersuites != NULL)
1608 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
1609#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001610 if (src->sni_expr != NULL)
1611 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001612
1613#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
1614 if (src->ssl_ctx.alpn_str) {
1615 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1616 if (srv->ssl_ctx.alpn_str) {
1617 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1618 src->ssl_ctx.alpn_len);
1619 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1620 }
1621 }
1622#endif
1623#ifdef OPENSSL_NPN_NEGOTIATED
1624 if (src->ssl_ctx.npn_str) {
1625 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1626 if (srv->ssl_ctx.npn_str) {
1627 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1628 src->ssl_ctx.npn_len);
1629 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1630 }
1631 }
1632#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001633}
1634#endif
1635
1636/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001637 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001638 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001639 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001640 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01001641int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001642{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001643 char *hostname_dn;
1644 int hostname_len, hostname_dn_len;
1645
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001646 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001647 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001648
Christopher Faulet67957bd2017-09-27 11:00:59 +02001649 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001650 hostname_dn = trash.area;
Emeric Brund30e9a12020-12-23 18:49:16 +01001651 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len + 1,
1652 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02001653 if (hostname_dn_len == -1)
1654 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001655
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001656
Christopher Faulet67957bd2017-09-27 11:00:59 +02001657 free(srv->hostname);
1658 free(srv->hostname_dn);
1659 srv->hostname = strdup(hostname);
1660 srv->hostname_dn = strdup(hostname_dn);
1661 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001662 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001663 goto err;
1664
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001665 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001666
1667 err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001668 ha_free(&srv->hostname);
1669 ha_free(&srv->hostname_dn);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001670 return -1;
1671}
1672
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001673/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001674 * Copy <src> server settings to <srv> server allocating
1675 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001676 * This function is not supposed to be called at any time, but only
1677 * during server settings parsing or during server allocations from
1678 * a server template, and just after having calloc()'ed a new server.
1679 * So, <src> may only be a default server (when parsing server settings)
1680 * or a server template (during server allocations from a server template).
1681 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1682 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001683 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001684static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001685{
1686 /* Connection source settings copy */
1687 srv_conn_src_cpy(srv, src);
1688
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001689 if (srv_tmpl) {
1690 srv->addr = src->addr;
1691 srv->svc_port = src->svc_port;
1692 }
1693
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001694 srv->pp_opts = src->pp_opts;
1695 if (src->rdr_pfx != NULL) {
1696 srv->rdr_pfx = strdup(src->rdr_pfx);
1697 srv->rdr_len = src->rdr_len;
1698 }
1699 if (src->cookie != NULL) {
1700 srv->cookie = strdup(src->cookie);
1701 srv->cklen = src->cklen;
1702 }
1703 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01001704 srv->check.addr = src->check.addr;
1705 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001706 srv->check.use_ssl = src->check.use_ssl;
1707 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01001708 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01001709 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05001710 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001711 /* Note: 'flags' field has potentially been already initialized. */
1712 srv->flags |= src->flags;
1713 srv->do_check = src->do_check;
1714 srv->do_agent = src->do_agent;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001715 srv->check.inter = src->check.inter;
1716 srv->check.fastinter = src->check.fastinter;
1717 srv->check.downinter = src->check.downinter;
1718 srv->agent.use_ssl = src->agent.use_ssl;
1719 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001720
1721 if (src->agent.tcpcheck_rules) {
1722 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
1723 if (srv->agent.tcpcheck_rules) {
1724 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
1725 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
1726 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
1727 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
1728 &src->agent.tcpcheck_rules->preset_vars);
1729 }
1730 }
1731
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001732 srv->agent.inter = src->agent.inter;
1733 srv->agent.fastinter = src->agent.fastinter;
1734 srv->agent.downinter = src->agent.downinter;
1735 srv->maxqueue = src->maxqueue;
1736 srv->minconn = src->minconn;
1737 srv->maxconn = src->maxconn;
1738 srv->slowstart = src->slowstart;
1739 srv->observe = src->observe;
1740 srv->onerror = src->onerror;
1741 srv->onmarkeddown = src->onmarkeddown;
1742 srv->onmarkedup = src->onmarkedup;
1743 if (src->trackit != NULL)
1744 srv->trackit = strdup(src->trackit);
1745 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1746 srv->uweight = srv->iweight = src->iweight;
1747
1748 srv->check.send_proxy = src->check.send_proxy;
1749 /* health: up, but will fall down at first failure */
1750 srv->check.rise = srv->check.health = src->check.rise;
1751 srv->check.fall = src->check.fall;
1752
1753 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001754 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1755 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1756 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001757 srv->check.state |= CHK_ST_PAUSED;
1758 srv->check.health = 0;
1759 }
1760
1761 /* health: up but will fall down at first failure */
1762 srv->agent.rise = srv->agent.health = src->agent.rise;
1763 srv->agent.fall = src->agent.fall;
1764
1765 if (src->resolvers_id != NULL)
1766 srv->resolvers_id = strdup(src->resolvers_id);
Emeric Brun21fbeed2020-12-23 18:01:04 +01001767 srv->resolv_opts.family_prio = src->resolv_opts.family_prio;
1768 srv->resolv_opts.accept_duplicate_ip = src->resolv_opts.accept_duplicate_ip;
1769 srv->resolv_opts.ignore_weight = src->resolv_opts.ignore_weight;
1770 if (srv->resolv_opts.family_prio == AF_UNSPEC)
1771 srv->resolv_opts.family_prio = AF_INET6;
1772 memcpy(srv->resolv_opts.pref_net,
1773 src->resolv_opts.pref_net,
1774 sizeof srv->resolv_opts.pref_net);
1775 srv->resolv_opts.pref_net_nb = src->resolv_opts.pref_net_nb;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001776
1777 srv->init_addr_methods = src->init_addr_methods;
1778 srv->init_addr = src->init_addr;
1779#if defined(USE_OPENSSL)
1780 srv_ssl_settings_cpy(srv, src);
1781#endif
1782#ifdef TCP_USER_TIMEOUT
1783 srv->tcp_ut = src->tcp_ut;
1784#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001785 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001786 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001787 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01001788 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01001789 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001790
Olivier Houchard8da5f982017-08-04 18:35:36 +02001791 if (srv_tmpl)
1792 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001793
1794 srv->check.via_socks4 = src->check.via_socks4;
1795 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001796}
1797
Willy Tarreau198e92a2021-03-05 10:23:32 +01001798/* allocate a server and attach it to the global servers_list. Returns
1799 * the server on success, otherwise NULL.
1800 */
William Lallemand313bfd12018-10-26 14:47:32 +02001801struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001802{
1803 struct server *srv;
1804
1805 srv = calloc(1, sizeof *srv);
1806 if (!srv)
1807 return NULL;
1808
1809 srv->obj_type = OBJ_TYPE_SERVER;
1810 srv->proxy = proxy;
Patrick Hemmer0355dab2018-05-11 12:52:31 -04001811 srv->pendconns = EB_ROOT;
Willy Tarreau198e92a2021-03-05 10:23:32 +01001812 LIST_ADDQ(&servers_list, &srv->global_list);
Christopher Faulet40a007c2017-07-03 15:41:01 +02001813
Emeric Brun52a91d32017-08-31 14:41:55 +02001814 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001815 srv->last_change = now.tv_sec;
1816
Christopher Faulet38290462020-04-21 11:46:40 +02001817 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001818 srv->check.status = HCHK_STATUS_INI;
1819 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01001820 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02001821 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001822
Christopher Faulet38290462020-04-21 11:46:40 +02001823 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001824 srv->agent.status = HCHK_STATUS_INI;
1825 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01001826 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001827 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
Frédéric Lécaillef46c10c2020-11-23 14:29:28 +01001828#if defined(USE_QUIC)
1829 srv->cids = EB_ROOT_UNIQUE;
1830#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001831
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01001832 srv->extra_counters = NULL;
William Lallemand3ce6eed2021-02-08 10:43:44 +01001833#ifdef USE_OPENSSL
1834 HA_RWLOCK_INIT(&srv->ssl_ctx.lock);
1835#endif
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01001836
Willy Tarreau975b1552019-06-06 16:25:55 +02001837 /* please don't put default server settings here, they are set in
Willy Tarreau144289b2021-02-12 08:19:01 +01001838 * proxy_preset_defaults().
Willy Tarreau975b1552019-06-06 16:25:55 +02001839 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001840 return srv;
1841}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001842
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001843#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1844static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
1845 struct server *srv, struct proxy *proxy)
1846{
1847 int ret;
1848 char *err = NULL;
1849
1850 if (!srv->sni_expr)
1851 return 0;
1852
1853 ret = server_parse_sni_expr(srv, proxy, &err);
1854 if (!ret)
1855 return 0;
1856
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001857 display_parser_err(file, linenum, args, cur_arg, ret, &err);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001858 free(err);
1859
1860 return ret;
1861}
1862#endif
1863
1864/*
1865 * Server initializations finalization.
1866 * Initialize health check, agent check and SNI expression if enabled.
1867 * Must not be called for a default server instance.
1868 */
1869static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
1870 struct server *srv, struct proxy *px)
1871{
Christopher Fauletb3b53522020-04-27 11:17:10 +02001872#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001873 int ret;
Christopher Fauletb3b53522020-04-27 11:17:10 +02001874#endif
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001875
Christopher Faulet8892e5d2020-03-26 19:48:20 +01001876 if (srv->do_check && srv->trackit) {
1877 ha_alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1878 file, linenum);
1879 return ERR_ALERT | ERR_FATAL;
1880 }
1881
1882 if (srv->do_agent && !srv->agent.port) {
1883 ha_alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
1884 file, linenum, srv->id);
1885 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001886 }
1887
1888#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1889 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
1890 return ret;
1891#endif
1892
1893 if (srv->flags & SRV_F_BACKUP)
1894 px->srv_bck++;
1895 else
1896 px->srv_act++;
1897 srv_lb_commit_status(srv);
1898
1899 return 0;
1900}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001901
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001902/*
1903 * Parse as much as possible such a range string argument: low[-high]
1904 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
1905 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
1906 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
1907 * Returns 0 if succeeded, -1 if not.
1908 */
1909static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
1910{
1911 char *nb_high_arg;
1912
1913 *nb_high = 0;
1914 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001915 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001916
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001917 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001918 *nb_high_arg++ = '\0';
1919 *nb_high = atoi(nb_high_arg);
1920 }
1921 else {
1922 *nb_high += *nb_low;
1923 *nb_low = 1;
1924 }
1925
1926 if (*nb_low < 0 || *nb_high < *nb_low)
1927 return -1;
1928
1929 return 0;
1930}
1931
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001932static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
1933{
1934 chunk_printf(&trash, "%s%d", prefix, nb);
1935 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001936 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001937}
1938
1939/*
1940 * Initialize as much as possible servers from <srv> server template.
1941 * Note that a server template is a special server with
1942 * a few different parameters than a server which has
1943 * been parsed mostly the same way as a server.
Joseph Herlant44466822018-11-15 08:57:51 -08001944 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001945 * 'srv' template included.
1946 */
1947static int server_template_init(struct server *srv, struct proxy *px)
1948{
1949 int i;
1950 struct server *newsrv;
1951
1952 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 +02001953 newsrv = new_server(px);
1954 if (!newsrv)
1955 goto err;
1956
Christopher Faulet75bef002020-11-02 22:04:55 +01001957 newsrv->conf.file = strdup(srv->conf.file);
1958 newsrv->conf.line = srv->conf.line;
1959
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001960 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001961 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001962#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1963 if (newsrv->sni_expr) {
1964 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
1965 if (!newsrv->ssl_ctx.sni)
1966 goto err;
1967 }
1968#endif
1969 /* Set this new server ID. */
1970 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
1971
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001972 /* Linked backwards first. This will be restablished after parsing. */
1973 newsrv->next = px->srv;
1974 px->srv = newsrv;
1975 }
1976 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1977
1978 return i - srv->tmpl_info.nb_low;
1979
1980 err:
1981 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1982 if (newsrv) {
1983#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1984 release_sample_expr(newsrv->ssl_ctx.sni);
1985#endif
1986 free_check(&newsrv->agent);
1987 free_check(&newsrv->check);
Willy Tarreau198e92a2021-03-05 10:23:32 +01001988 LIST_DEL(&newsrv->global_list);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001989 }
1990 free(newsrv);
1991 return i - srv->tmpl_info.nb_low;
1992}
1993
Emeric Brund3db3842020-07-21 16:54:36 +02001994int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy,
Willy Tarreaubb8669a2021-02-12 12:15:05 +01001995 const struct proxy *defproxy, int parse_addr, int in_peers_section, int initial_resolve)
Willy Tarreau272adea2014-03-31 10:39:59 +02001996{
1997 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001998 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001999 char *errmsg = NULL;
2000 int err_code = 0;
2001 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02002002 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02002003
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002004 if (strcmp(args[0], "server") == 0 ||
2005 strcmp(args[0], "peer") == 0 ||
2006 strcmp(args[0], "default-server") == 0 ||
2007 strcmp(args[0], "server-template") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002008 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01002009 int defsrv = (*args[0] == 'd');
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002010 int srv = !defsrv && (*args[0] == 'p' || strcmp(args[0], "server") == 0);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002011 int srv_tmpl = !defsrv && !srv;
2012 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002013
2014 if (!defsrv && curproxy == defproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002015 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002016 err_code |= ERR_ALERT | ERR_FATAL;
2017 goto out;
2018 }
Christopher Faulete3bdc812021-01-13 13:14:13 +01002019 else if (failifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL)) {
2020 err_code |= ERR_ALERT | ERR_FATAL;
2021 goto out;
2022 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002023
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002024 /* There is no mandatory first arguments for default server. */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002025 if (srv && parse_addr) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002026 if (!*args[2]) {
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +02002027 if (in_peers_section) {
2028 return 0;
2029 }
2030 else {
2031 /* 'server' line number of argument check. */
2032 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
2033 file, linenum, args[0]);
2034 err_code |= ERR_ALERT | ERR_FATAL;
2035 goto out;
2036 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002037 }
2038
2039 err = invalid_char(args[1]);
2040 }
2041 else if (srv_tmpl) {
2042 if (!*args[3]) {
2043 /* 'server-template' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002044 ha_alert("parsing [%s:%d] : '%s' expects <prefix> <nb | range> <addr>[:<port>] as arguments.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002045 file, linenum, args[0]);
2046 err_code |= ERR_ALERT | ERR_FATAL;
2047 goto out;
2048 }
2049
2050 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002051 }
2052
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002053 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002054 ha_alert("parsing [%s:%d] : character '%c' is not permitted in %s %s '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002055 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002056 err_code |= ERR_ALERT | ERR_FATAL;
2057 goto out;
2058 }
2059
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002060 cur_arg = 2;
2061 if (srv_tmpl) {
2062 /* Parse server-template <nb | range> arg. */
2063 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002064 ha_alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002065 file, linenum, args[0], args[cur_arg]);
2066 err_code |= ERR_ALERT | ERR_FATAL;
2067 goto out;
2068 }
2069 cur_arg++;
2070 }
2071
Willy Tarreau272adea2014-03-31 10:39:59 +02002072 if (!defsrv) {
2073 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002074 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002075
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002076 newsrv = new_server(curproxy);
2077 if (!newsrv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002078 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Willy Tarreau272adea2014-03-31 10:39:59 +02002079 err_code |= ERR_ALERT | ERR_ABORT;
2080 goto out;
2081 }
2082
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002083 if (srv_tmpl) {
2084 newsrv->tmpl_info.nb_low = tmpl_range_low;
2085 newsrv->tmpl_info.nb_high = tmpl_range_high;
2086 }
2087
Willy Tarreau272adea2014-03-31 10:39:59 +02002088 /* the servers are linked backwards first */
2089 newsrv->next = curproxy->srv;
2090 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02002091 newsrv->conf.file = strdup(file);
2092 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002093 /* Note: for a server template, its id is its prefix.
2094 * This is a temporary id which will be used for server allocations to come
2095 * after parsing.
2096 */
2097 if (srv)
2098 newsrv->id = strdup(args[1]);
2099 else
2100 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002101
2102 /* several ways to check the port component :
2103 * - IP => port=+0, relative (IPv4 only)
2104 * - IP: => port=+0, relative
2105 * - IP:N => port=N, absolute
2106 * - IP:+N => port=+N, relative
2107 * - IP:-N => port=-N, relative
2108 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002109 if (!parse_addr)
2110 goto skip_addr;
2111
Willy Tarreau65ec4e32020-09-16 19:17:08 +02002112 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, NULL, NULL,
2113 &errmsg, NULL, &fqdn,
2114 (initial_resolve ? PA_O_RESOLVE : 0) | PA_O_PORT_OK | PA_O_PORT_OFS | PA_O_STREAM | PA_O_XPRT | PA_O_CONNECT);
Willy Tarreau272adea2014-03-31 10:39:59 +02002115 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002116 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau272adea2014-03-31 10:39:59 +02002117 err_code |= ERR_ALERT | ERR_FATAL;
2118 goto out;
2119 }
2120
Willy Tarreau272adea2014-03-31 10:39:59 +02002121 if (!port1 || !port2) {
2122 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002123 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002124 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002125
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002126 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002127 if (fqdn) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002128 if (fqdn[0] == '_') { /* SRV record */
Olivier Houchard8da5f982017-08-04 18:35:36 +02002129 /* Check if a SRV request already exists, and if not, create it */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002130 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
Emeric Brun08622d32020-12-23 17:41:43 +01002131 newsrv->srvrq = new_resolv_srvrq(newsrv, fqdn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02002132 if (newsrv->srvrq == NULL) {
Olivier Houchard8da5f982017-08-04 18:35:36 +02002133 err_code |= ERR_ALERT | ERR_FATAL;
2134 goto out;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002135 }
2136 }
2137 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002138 ha_alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
Christopher Faulet67957bd2017-09-27 11:00:59 +02002139 file, linenum, newsrv->id);
2140 err_code |= ERR_ALERT | ERR_FATAL;
2141 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002142 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002143 }
2144
Willy Tarreau272adea2014-03-31 10:39:59 +02002145 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002146 newsrv->svc_port = port;
Thayne McCombs92149f92020-11-20 01:28:26 -07002147 // we don't need to lock the server here, because
2148 // we are in the process of initializing
2149 srv_set_addr_desc(newsrv);
Willy Tarreau272adea2014-03-31 10:39:59 +02002150
Olivier Houchard8da5f982017-08-04 18:35:36 +02002151 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002152 ha_alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002153 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002154 err_code |= ERR_ALERT | ERR_FATAL;
2155 goto out;
2156 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002157
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002158 cur_arg++;
2159 skip_addr:
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002160 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002161 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002162 HA_SPIN_INIT(&newsrv->lock);
Willy Tarreau272adea2014-03-31 10:39:59 +02002163 } else {
2164 newsrv = &curproxy->defsrv;
2165 cur_arg = 1;
Emeric Brun21fbeed2020-12-23 18:01:04 +01002166 newsrv->resolv_opts.family_prio = AF_INET6;
2167 newsrv->resolv_opts.accept_duplicate_ip = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002168 }
2169
2170 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002171 if (strcmp(args[cur_arg], "init-addr") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002172 char *p, *end;
2173 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002174 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002175
2176 newsrv->init_addr_methods = 0;
2177 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2178
2179 for (p = args[cur_arg + 1]; *p; p = end) {
2180 /* cut on next comma */
2181 for (end = p; *end && *end != ','; end++);
2182 if (*end)
2183 *(end++) = 0;
2184
Willy Tarreau4310d362016-11-02 15:05:56 +01002185 memset(&sa, 0, sizeof(sa));
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002186 if (strcmp(p, "libc") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002187 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2188 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002189 else if (strcmp(p, "last") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002190 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2191 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002192 else if (strcmp(p, "none") == 0) {
Willy Tarreau37ebe122016-11-04 15:17:58 +01002193 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2194 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002195 else if (str2ip2(p, &sa, 0)) {
2196 if (is_addr(&newsrv->init_addr)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002197 ha_alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
Willy Tarreau4310d362016-11-02 15:05:56 +01002198 file, linenum, args[cur_arg], p);
2199 err_code |= ERR_ALERT | ERR_FATAL;
2200 goto out;
2201 }
2202 newsrv->init_addr = sa;
2203 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2204 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002205 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002206 ha_alert("parsing [%s:%d]: '%s' : unknown init-addr method '%s', supported methods are 'libc', 'last', 'none'.\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002207 file, linenum, args[cur_arg], p);
2208 err_code |= ERR_ALERT | ERR_FATAL;
2209 goto out;
2210 }
2211 if (!done) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002212 ha_alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002213 file, linenum, args[cur_arg], p);
2214 err_code |= ERR_ALERT | ERR_FATAL;
2215 goto out;
2216 }
2217 }
2218 cur_arg += 2;
2219 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002220 else if (strcmp(args[cur_arg], "resolvers") == 0) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002221 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002222 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2223 cur_arg += 2;
2224 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002225 else if (strcmp(args[cur_arg], "resolve-opts") == 0) {
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002226 char *p, *end;
2227
2228 for (p = args[cur_arg + 1]; *p; p = end) {
2229 /* cut on next comma */
2230 for (end = p; *end && *end != ','; end++);
2231 if (*end)
2232 *(end++) = 0;
2233
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002234 if (strcmp(p, "allow-dup-ip") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002235 newsrv->resolv_opts.accept_duplicate_ip = 1;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002236 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002237 else if (strcmp(p, "ignore-weight") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002238 newsrv->resolv_opts.ignore_weight = 1;
Daniel Corbettf8716912019-11-17 09:48:56 -05002239 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002240 else if (strcmp(p, "prevent-dup-ip") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002241 newsrv->resolv_opts.accept_duplicate_ip = 0;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002242 }
2243 else {
Daniel Corbettf8716912019-11-17 09:48:56 -05002244 ha_alert("parsing [%s:%d]: '%s' : unknown resolve-opts option '%s', supported methods are 'allow-dup-ip', 'ignore-weight', and 'prevent-dup-ip'.\n",
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002245 file, linenum, args[cur_arg], p);
2246 err_code |= ERR_ALERT | ERR_FATAL;
2247 goto out;
2248 }
2249 }
2250
2251 cur_arg += 2;
2252 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002253 else if (strcmp(args[cur_arg], "resolve-prefer") == 0) {
2254 if (strcmp(args[cur_arg + 1], "ipv4") == 0)
Emeric Brun21fbeed2020-12-23 18:01:04 +01002255 newsrv->resolv_opts.family_prio = AF_INET;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002256 else if (strcmp(args[cur_arg + 1], "ipv6") == 0)
Emeric Brun21fbeed2020-12-23 18:01:04 +01002257 newsrv->resolv_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002258 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002259 ha_alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002260 file, linenum, args[cur_arg]);
2261 err_code |= ERR_ALERT | ERR_FATAL;
2262 goto out;
2263 }
2264 cur_arg += 2;
2265 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002266 else if (strcmp(args[cur_arg], "resolve-net") == 0) {
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002267 char *p, *e;
2268 unsigned char mask;
Emeric Brun21fbeed2020-12-23 18:01:04 +01002269 struct resolv_options *opt;
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002270
2271 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002272 ha_alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002273 file, linenum, args[cur_arg]);
2274 err_code |= ERR_ALERT | ERR_FATAL;
2275 goto out;
2276 }
2277
Emeric Brun21fbeed2020-12-23 18:01:04 +01002278 opt = &newsrv->resolv_opts;
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002279
2280 /* Split arguments by comma, and convert it from ipv4 or ipv6
2281 * string network in in_addr or in6_addr.
2282 */
2283 p = args[cur_arg + 1];
2284 e = p;
2285 while (*p != '\0') {
Joseph Herlant44466822018-11-15 08:57:51 -08002286 /* If no room available, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002287 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002288 ha_alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002289 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2290 err_code |= ERR_ALERT | ERR_FATAL;
2291 goto out;
2292 }
2293 /* look for end or comma. */
2294 while (*e != ',' && *e != '\0')
2295 e++;
2296 if (*e == ',') {
2297 *e = '\0';
2298 e++;
2299 }
2300 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2301 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2302 /* Try to convert input string from ipv4 or ipv6 network. */
2303 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2304 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2305 &mask)) {
2306 /* Try to convert input string from ipv6 network. */
2307 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2308 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2309 } else {
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002310 /* All network conversions fail, return error. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002311 ha_alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002312 file, linenum, args[cur_arg], p);
2313 err_code |= ERR_ALERT | ERR_FATAL;
2314 goto out;
2315 }
2316 opt->pref_net_nb++;
2317 p = e;
2318 }
2319
2320 cur_arg += 2;
2321 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002322 else if (strcmp(args[cur_arg], "weight") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002323 int w;
2324 w = atol(args[cur_arg + 1]);
2325 if (w < 0 || w > SRV_UWGHT_MAX) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002326 ha_alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002327 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2328 err_code |= ERR_ALERT | ERR_FATAL;
2329 goto out;
2330 }
2331 newsrv->uweight = newsrv->iweight = w;
2332 cur_arg += 2;
2333 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002334 else if (strcmp(args[cur_arg], "log-proto") == 0) {
2335 if (strcmp(args[cur_arg + 1], "legacy") == 0)
Emeric Brun97556472020-05-30 01:42:45 +02002336 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002337 else if (strcmp(args[cur_arg + 1], "octet-count") == 0)
Emeric Brun97556472020-05-30 01:42:45 +02002338 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
2339 else {
2340 ha_alert("parsing [%s:%d]: '%s' expects one of 'legacy' or "
2341 "'octet-count' but got '%s'\n",
2342 file, linenum, args[cur_arg], args[cur_arg + 1]);
2343 err_code |= ERR_ALERT | ERR_FATAL;
2344 goto out;
2345 }
2346 cur_arg += 2;
2347 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002348 else if (strcmp(args[cur_arg], "minconn") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002349 newsrv->minconn = atol(args[cur_arg + 1]);
2350 cur_arg += 2;
2351 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002352 else if (strcmp(args[cur_arg], "maxconn") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002353 newsrv->maxconn = atol(args[cur_arg + 1]);
2354 cur_arg += 2;
2355 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002356 else if (strcmp(args[cur_arg], "maxqueue") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002357 newsrv->maxqueue = atol(args[cur_arg + 1]);
2358 cur_arg += 2;
2359 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002360 else if (strcmp(args[cur_arg], "slowstart") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002361 /* slowstart is stored in seconds */
2362 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02002363
2364 if (err == PARSE_TIME_OVER) {
2365 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).\n",
2366 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2367 err_code |= ERR_ALERT | ERR_FATAL;
2368 goto out;
2369 }
2370 else if (err == PARSE_TIME_UNDER) {
2371 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.\n",
2372 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2373 err_code |= ERR_ALERT | ERR_FATAL;
2374 goto out;
2375 }
2376 else if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002377 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002378 file, linenum, *err, newsrv->id);
2379 err_code |= ERR_ALERT | ERR_FATAL;
2380 goto out;
2381 }
2382 newsrv->slowstart = (val + 999) / 1000;
2383 cur_arg += 2;
2384 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002385 else if (strcmp(args[cur_arg], "on-error") == 0) {
2386 if (strcmp(args[cur_arg + 1], "fastinter") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002387 newsrv->onerror = HANA_ONERR_FASTINTER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002388 else if (strcmp(args[cur_arg + 1], "fail-check") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002389 newsrv->onerror = HANA_ONERR_FAILCHK;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002390 else if (strcmp(args[cur_arg + 1], "sudden-death") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002391 newsrv->onerror = HANA_ONERR_SUDDTH;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002392 else if (strcmp(args[cur_arg + 1], "mark-down") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002393 newsrv->onerror = HANA_ONERR_MARKDWN;
2394 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002395 ha_alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
Willy Tarreau272adea2014-03-31 10:39:59 +02002396 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2397 file, linenum, args[cur_arg], args[cur_arg + 1]);
2398 err_code |= ERR_ALERT | ERR_FATAL;
2399 goto out;
2400 }
2401
2402 cur_arg += 2;
2403 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002404 else if (strcmp(args[cur_arg], "on-marked-down") == 0) {
2405 if (strcmp(args[cur_arg + 1], "shutdown-sessions") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002406 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2407 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002408 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002409 file, linenum, args[cur_arg], args[cur_arg + 1]);
2410 err_code |= ERR_ALERT | ERR_FATAL;
2411 goto out;
2412 }
2413
2414 cur_arg += 2;
2415 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002416 else if (strcmp(args[cur_arg], "on-marked-up") == 0) {
2417 if (strcmp(args[cur_arg + 1], "shutdown-backup-sessions") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002418 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2419 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002420 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002421 file, linenum, args[cur_arg], args[cur_arg + 1]);
2422 err_code |= ERR_ALERT | ERR_FATAL;
2423 goto out;
2424 }
2425
2426 cur_arg += 2;
2427 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002428 else if (strcmp(args[cur_arg], "error-limit") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002429 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002430 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002431 file, linenum, args[cur_arg]);
2432 err_code |= ERR_ALERT | ERR_FATAL;
2433 goto out;
2434 }
2435
2436 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2437
2438 if (newsrv->consecutive_errors_limit <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002439 ha_alert("parsing [%s:%d]: %s has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002440 file, linenum, args[cur_arg]);
2441 err_code |= ERR_ALERT | ERR_FATAL;
2442 goto out;
2443 }
2444 cur_arg += 2;
2445 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002446 else if (strcmp(args[cur_arg], "usesrc") == 0) { /* address to use outside: needs "source" first */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002447 ha_alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002448 file, linenum, "usesrc", "source");
2449 err_code |= ERR_ALERT | ERR_FATAL;
2450 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002451 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002452 else {
Willy Tarreau272adea2014-03-31 10:39:59 +02002453 struct srv_kw *kw;
Willy Tarreau49c2b452021-03-12 09:58:04 +01002454 const char *best;
Willy Tarreau272adea2014-03-31 10:39:59 +02002455
2456 kw = srv_find_kw(args[cur_arg]);
2457 if (kw) {
2458 char *err = NULL;
2459 int code;
2460
2461 if (!kw->parse) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002462 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not implemented in this version (check build options).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002463 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002464 if (kw->skip != -1)
2465 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002466 err_code |= ERR_ALERT | ERR_FATAL;
2467 goto out;
2468 }
2469
2470 if (defsrv && !kw->default_ok) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002471 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002472 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002473 if (kw->skip != -1)
2474 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002475 err_code |= ERR_ALERT;
2476 continue;
2477 }
2478
2479 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2480 err_code |= code;
2481
2482 if (code) {
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002483 display_parser_err(file, linenum, args, cur_arg, code, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002484 if (code & ERR_FATAL) {
2485 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002486 if (kw->skip != -1)
2487 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002488 goto out;
2489 }
2490 }
2491 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002492 if (kw->skip != -1)
2493 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002494 continue;
2495 }
2496
Willy Tarreau49c2b452021-03-12 09:58:04 +01002497 best = srv_find_best_kw(args[cur_arg]);
2498 if (best)
2499 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'; did you mean '%s' maybe ?\n",
2500 file, linenum, args[0], args[1], args[cur_arg], best);
2501 else
2502 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.\n",
2503 file, linenum, args[0], args[1], args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002504
2505 err_code |= ERR_ALERT | ERR_FATAL;
2506 goto out;
2507 }
2508 }
2509
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002510 if (!defsrv)
2511 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2512 if (err_code & ERR_FATAL)
2513 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002514 if (srv_tmpl)
2515 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002516 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002517 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002518 return 0;
2519
2520 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002521 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002522 free(errmsg);
2523 return err_code;
2524}
2525
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002526/* Returns a pointer to the first server matching either id <id>.
2527 * NULL is returned if no match is found.
2528 * the lookup is performed in the backend <bk>
2529 */
2530struct server *server_find_by_id(struct proxy *bk, int id)
2531{
2532 struct eb32_node *eb32;
2533 struct server *curserver;
2534
2535 if (!bk || (id ==0))
2536 return NULL;
2537
2538 /* <bk> has no backend capabilities, so it can't have a server */
2539 if (!(bk->cap & PR_CAP_BE))
2540 return NULL;
2541
2542 curserver = NULL;
2543
2544 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2545 if (eb32)
2546 curserver = container_of(eb32, struct server, conf.id);
2547
2548 return curserver;
2549}
2550
2551/* Returns a pointer to the first server matching either name <name>, or id
2552 * if <name> starts with a '#'. NULL is returned if no match is found.
2553 * the lookup is performed in the backend <bk>
2554 */
2555struct server *server_find_by_name(struct proxy *bk, const char *name)
2556{
2557 struct server *curserver;
2558
2559 if (!bk || !name)
2560 return NULL;
2561
2562 /* <bk> has no backend capabilities, so it can't have a server */
2563 if (!(bk->cap & PR_CAP_BE))
2564 return NULL;
2565
2566 curserver = NULL;
2567 if (*name == '#') {
2568 curserver = server_find_by_id(bk, atoi(name + 1));
2569 if (curserver)
2570 return curserver;
2571 }
2572 else {
2573 curserver = bk->srv;
2574
2575 while (curserver && (strcmp(curserver->id, name) != 0))
2576 curserver = curserver->next;
2577
2578 if (curserver)
2579 return curserver;
2580 }
2581
2582 return NULL;
2583}
2584
2585struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2586{
2587 struct server *byname;
2588 struct server *byid;
2589
2590 if (!name && !id)
2591 return NULL;
2592
2593 if (diff)
2594 *diff = 0;
2595
2596 byname = byid = NULL;
2597
2598 if (name) {
2599 byname = server_find_by_name(bk, name);
2600 if (byname && (!id || byname->puid == id))
2601 return byname;
2602 }
2603
2604 /* remaining possibilities :
2605 * - name not set
2606 * - name set but not found
2607 * - name found but ID doesn't match
2608 */
2609 if (id) {
2610 byid = server_find_by_id(bk, id);
2611 if (byid) {
2612 if (byname) {
2613 /* use id only if forced by configuration */
2614 if (byid->flags & SRV_F_FORCED_ID) {
2615 if (diff)
2616 *diff |= 2;
2617 return byid;
2618 }
2619 else {
2620 if (diff)
2621 *diff |= 1;
2622 return byname;
2623 }
2624 }
2625
2626 /* remaining possibilities:
2627 * - name not set
2628 * - name set but not found
2629 */
2630 if (name && diff)
2631 *diff |= 2;
2632 return byid;
2633 }
2634
2635 /* id bot found */
2636 if (byname) {
2637 if (diff)
2638 *diff |= 1;
2639 return byname;
2640 }
2641 }
2642
2643 return NULL;
2644}
2645
Simon Horman7d09b9a2013-02-12 10:45:51 +09002646/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02002647 * update a server's current IP address.
2648 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
2649 * ip is in network format.
2650 * updater is a string which contains an information about the requester of the update.
2651 * updater is used if not NULL.
2652 *
2653 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02002654 *
2655 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02002656 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002657int srv_update_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02002658{
Christopher Fauletd6c6b5f2020-09-08 10:27:24 +02002659 /* save the new IP family & address if necessary */
2660 switch (ip_sin_family) {
2661 case AF_INET:
2662 if (s->addr.ss_family == ip_sin_family &&
2663 !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
2664 return 0;
2665 break;
2666 case AF_INET6:
2667 if (s->addr.ss_family == ip_sin_family &&
2668 !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
2669 return 0;
2670 break;
2671 };
2672
Baptiste Assmann14e40142015-04-14 01:13:07 +02002673 /* generates a log line and a warning on stderr */
2674 if (1) {
2675 /* book enough space for both IPv4 and IPv6 */
2676 char oldip[INET6_ADDRSTRLEN];
2677 char newip[INET6_ADDRSTRLEN];
2678
2679 memset(oldip, '\0', INET6_ADDRSTRLEN);
2680 memset(newip, '\0', INET6_ADDRSTRLEN);
2681
2682 /* copy old IP address in a string */
2683 switch (s->addr.ss_family) {
2684 case AF_INET:
2685 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
2686 break;
2687 case AF_INET6:
2688 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
2689 break;
Christopher Fauletb0b76072020-09-08 10:38:40 +02002690 default:
2691 strcpy(oldip, "(none)");
2692 break;
Baptiste Assmann14e40142015-04-14 01:13:07 +02002693 };
2694
2695 /* copy new IP address in a string */
2696 switch (ip_sin_family) {
2697 case AF_INET:
2698 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
2699 break;
2700 case AF_INET6:
2701 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
2702 break;
2703 };
2704
2705 /* save log line into a buffer */
2706 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
2707 s->proxy->id, s->id, oldip, newip, updater);
2708
2709 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002710 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002711
2712 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002713 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002714 }
2715
2716 /* save the new IP family */
2717 s->addr.ss_family = ip_sin_family;
2718 /* save the new IP address */
2719 switch (ip_sin_family) {
2720 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02002721 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002722 break;
2723 case AF_INET6:
2724 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
2725 break;
2726 };
Olivier Houchard4e694042017-03-14 20:01:29 +01002727 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07002728 srv_set_addr_desc(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002729
2730 return 0;
2731}
2732
William Dauchy7cabc062021-02-11 22:51:24 +01002733/* update agent health check address and port
2734 * addr can be ip4/ip6 or a hostname
2735 * if one error occurs, don't apply anything
2736 * must be called with the server lock held.
2737 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002738const char *srv_update_agent_addr_port(struct server *s, const char *addr, const char *port)
William Dauchy7cabc062021-02-11 22:51:24 +01002739{
2740 struct sockaddr_storage sk;
2741 struct buffer *msg;
2742 int new_port;
2743
2744 msg = get_trash_chunk();
2745 chunk_reset(msg);
2746
2747 if (!(s->agent.state & CHK_ST_ENABLED)) {
2748 chunk_strcat(msg, "agent checks are not enabled on this server");
2749 goto out;
2750 }
2751 if (addr) {
2752 memset(&sk, 0, sizeof(struct sockaddr_storage));
2753 if (str2ip(addr, &sk) == NULL) {
2754 chunk_appendf(msg, "invalid addr '%s'", addr);
2755 goto out;
2756 }
2757 }
2758 if (port) {
2759 if (strl2irc(port, strlen(port), &new_port) != 0) {
2760 chunk_appendf(msg, "provided port is not an integer");
2761 goto out;
2762 }
2763 if (new_port < 0 || new_port > 65535) {
2764 chunk_appendf(msg, "provided port is invalid");
2765 goto out;
2766 }
2767 }
2768out:
2769 if (msg->data)
2770 return msg->area;
2771 else {
2772 if (addr)
2773 set_srv_agent_addr(s, &sk);
2774 if (port)
2775 set_srv_agent_port(s, new_port);
2776 }
2777 return NULL;
2778}
2779
William Dauchyb456e1f2021-02-11 22:51:23 +01002780/* update server health check address and port
2781 * addr must be ip4 or ip6, it won't be resolved
2782 * if one error occurs, don't apply anything
2783 * must be called with the server lock held.
2784 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002785const char *srv_update_check_addr_port(struct server *s, const char *addr, const char *port)
William Dauchyb456e1f2021-02-11 22:51:23 +01002786{
2787 struct sockaddr_storage sk;
2788 struct buffer *msg;
2789 int new_port;
2790
2791 msg = get_trash_chunk();
2792 chunk_reset(msg);
2793
2794 if (!(s->check.state & CHK_ST_ENABLED)) {
2795 chunk_strcat(msg, "health checks are not enabled on this server");
2796 goto out;
2797 }
2798 if (addr) {
2799 memset(&sk, 0, sizeof(struct sockaddr_storage));
2800 if (str2ip2(addr, &sk, 0) == NULL) {
2801 chunk_appendf(msg, "invalid addr '%s'", addr);
2802 goto out;
2803 }
2804 }
2805 if (port) {
2806 if (strl2irc(port, strlen(port), &new_port) != 0) {
2807 chunk_appendf(msg, "provided port is not an integer");
2808 goto out;
2809 }
2810 if (new_port < 0 || new_port > 65535) {
2811 chunk_appendf(msg, "provided port is invalid");
2812 goto out;
2813 }
2814 /* prevent the update of port to 0 if MAPPORTS are in use */
2815 if ((s->flags & SRV_F_MAPPORTS) && new_port == 0) {
2816 chunk_appendf(msg, "can't unset 'port' since MAPPORTS is in use");
2817 goto out;
2818 }
2819 }
2820out:
2821 if (msg->data)
2822 return msg->area;
2823 else {
2824 if (addr)
2825 s->check.addr = sk;
2826 if (port)
2827 s->check.port = new_port;
2828 }
2829 return NULL;
2830}
2831
Baptiste Assmann14e40142015-04-14 01:13:07 +02002832/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002833 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
2834 *
2835 * Caller can pass its name through <updater> to get it integrated in the response message
2836 * returned by the function.
2837 *
2838 * The function first does the following, in that order:
2839 * - validates the new addr and/or port
2840 * - checks if an update is required (new IP or port is different than current ones)
2841 * - checks the update is allowed:
2842 * - don't switch from/to a family other than AF_INET4 and AF_INET6
2843 * - allow all changes if no CHECKS are configured
2844 * - if CHECK is configured:
2845 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
2846 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
2847 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02002848 *
2849 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002850 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002851const char *srv_update_addr_port(struct server *s, const char *addr, const char *port, char *updater)
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002852{
2853 struct sockaddr_storage sa;
2854 int ret, port_change_required;
2855 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00002856 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02002857 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01002858 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002859
2860 msg = get_trash_chunk();
2861 chunk_reset(msg);
2862
2863 if (addr) {
2864 memset(&sa, 0, sizeof(struct sockaddr_storage));
2865 if (str2ip2(addr, &sa, 0) == NULL) {
2866 chunk_printf(msg, "Invalid addr '%s'", addr);
2867 goto out;
2868 }
2869
2870 /* changes are allowed on AF_INET* families only */
2871 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
2872 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
2873 goto out;
2874 }
2875
2876 /* collecting data currently setup */
2877 memset(current_addr, '\0', sizeof(current_addr));
2878 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
2879 /* changes are allowed on AF_INET* families only */
2880 if ((ret != AF_INET) && (ret != AF_INET6)) {
2881 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
2882 goto out;
2883 }
2884
2885 /* applying ADDR changes if required and allowed
2886 * ipcmp returns 0 when both ADDR are the same
2887 */
2888 if (ipcmp(&s->addr, &sa) == 0) {
2889 chunk_appendf(msg, "no need to change the addr");
2890 goto port;
2891 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002892 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01002893 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002894
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002895 /* update report for caller */
2896 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
2897 }
2898
2899 port:
2900 if (port) {
2901 char sign = '\0';
2902 char *endptr;
2903
2904 if (addr)
2905 chunk_appendf(msg, ", ");
2906
2907 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01002908 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002909
2910 /* check if PORT change is required */
2911 port_change_required = 0;
2912
2913 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04002914 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002915 new_port = strtol(port, &endptr, 10);
2916 if ((errno != 0) || (port == endptr)) {
2917 chunk_appendf(msg, "problem converting port '%s' to an int", port);
2918 goto out;
2919 }
2920
2921 /* check if caller triggers a port mapped or offset */
2922 if (sign == '-' || (sign == '+')) {
2923 /* check if server currently uses port map */
2924 if (!(s->flags & SRV_F_MAPPORTS)) {
2925 /* switch from fixed port to port map mandatorily triggers
2926 * a port change */
2927 port_change_required = 1;
2928 /* check is configured
2929 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
2930 * prevent PORT change if check doesn't have it's dedicated port while switching
2931 * to port mapping */
William Dauchy69f118d2021-02-03 22:30:07 +01002932 if (!s->check.port) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002933 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.");
2934 goto out;
2935 }
2936 }
2937 /* we're already using port maps */
2938 else {
2939 port_change_required = current_port != new_port;
2940 }
2941 }
2942 /* fixed port */
2943 else {
2944 port_change_required = current_port != new_port;
2945 }
2946
2947 /* applying PORT changes if required and update response message */
2948 if (port_change_required) {
2949 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01002950 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01002951 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002952
2953 /* prepare message */
2954 chunk_appendf(msg, "port changed from '");
2955 if (s->flags & SRV_F_MAPPORTS)
2956 chunk_appendf(msg, "+");
2957 chunk_appendf(msg, "%d' to '", current_port);
2958
2959 if (sign == '-') {
2960 s->flags |= SRV_F_MAPPORTS;
2961 chunk_appendf(msg, "%c", sign);
2962 /* just use for result output */
2963 new_port = -new_port;
2964 }
2965 else if (sign == '+') {
2966 s->flags |= SRV_F_MAPPORTS;
2967 chunk_appendf(msg, "%c", sign);
2968 }
2969 else {
2970 s->flags &= ~SRV_F_MAPPORTS;
2971 }
2972
2973 chunk_appendf(msg, "%d'", new_port);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002974 }
2975 else {
2976 chunk_appendf(msg, "no need to change the port");
2977 }
2978 }
2979
2980out:
William Dauchy6318d332020-05-02 21:52:36 +02002981 if (changed) {
2982 /* force connection cleanup on the given server */
2983 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01002984 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07002985 srv_set_addr_desc(s);
William Dauchy6318d332020-05-02 21:52:36 +02002986 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002987 if (updater)
2988 chunk_appendf(msg, " by '%s'", updater);
2989 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002990 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002991}
2992
Christopher Faulet5efdef22021-03-11 18:03:21 +01002993/*
2994 * update server status based on result of SRV resolution
2995 * returns:
2996 * 0 if server status is updated
2997 * 1 if server status has not changed
2998 *
2999 * Must be called with the server lock held.
3000 */
3001int srvrq_update_srv_status(struct server *s, int has_no_ip)
3002{
3003 if (!s->srvrq)
3004 return 1;
3005
3006 /* since this server has an IP, it can go back in production */
3007 if (has_no_ip == 0) {
3008 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3009 return 1;
3010 }
3011
3012 if (s->next_admin & SRV_ADMF_RMAINT)
3013 return 1;
3014
3015 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
3016 return 0;
3017}
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003018
3019/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003020 * update server status based on result of name resolution
3021 * returns:
3022 * 0 if server status is updated
3023 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003024 *
3025 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003026 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003027int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003028{
Emeric Brun750fe792020-12-23 16:51:12 +01003029 struct resolvers *resolvers = s->resolvers;
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003030 struct resolv_resolution *resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003031 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003032
Jerome Magnin012261a2020-07-28 13:38:22 +02003033 /* If resolution is NULL we're dealing with SRV records Additional records */
Christopher Faulet5efdef22021-03-11 18:03:21 +01003034 if (resolution == NULL)
3035 return srvrq_update_srv_status(s, has_no_ip);
Jerome Magnin012261a2020-07-28 13:38:22 +02003036
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003037 switch (resolution->status) {
3038 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003039 /* status when HAProxy has just (re)started.
3040 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003041 break;
3042
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003043 case RSLV_STATUS_VALID:
3044 /*
3045 * resume health checks
3046 * server will be turned back on if health check is safe
3047 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003048 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003049 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003050 return 1;
3051 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3052 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003053 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003054 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003055
Emeric Brun52a91d32017-08-31 14:41:55 +02003056 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003057 return 1;
3058 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3059 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3060 s->proxy->id, s->id);
3061
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003062 ha_warning("%s.\n", trash.area);
3063 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003064 return 0;
3065
3066 case RSLV_STATUS_NX:
3067 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003068 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3069 if (!tick_is_expired(exp, now_ms))
3070 break;
3071
3072 if (s->next_admin & SRV_ADMF_RMAINT)
3073 return 1;
3074 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3075 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003076
3077 case RSLV_STATUS_TIMEOUT:
3078 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003079 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3080 if (!tick_is_expired(exp, now_ms))
3081 break;
3082
3083 if (s->next_admin & SRV_ADMF_RMAINT)
3084 return 1;
3085 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3086 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003087
3088 case RSLV_STATUS_REFUSED:
3089 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003090 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3091 if (!tick_is_expired(exp, now_ms))
3092 break;
3093
3094 if (s->next_admin & SRV_ADMF_RMAINT)
3095 return 1;
3096 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3097 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003098
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003099 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003100 /* stop server if resolution failed for a long enough period */
3101 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3102 if (!tick_is_expired(exp, now_ms))
3103 break;
3104
3105 if (s->next_admin & SRV_ADMF_RMAINT)
3106 return 1;
3107 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3108 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003109 }
3110
3111 return 1;
3112}
3113
3114/*
3115 * Server Name Resolution valid response callback
3116 * It expects:
3117 * - <nameserver>: the name server which answered the valid response
3118 * - <response>: buffer containing a valid DNS response
3119 * - <response_len>: size of <response>
3120 * It performs the following actions:
3121 * - ignore response if current ip found and server family not met
3122 * - update with first new ip found if family is met and current IP is not found
3123 * returns:
3124 * 0 on error
3125 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003126 *
3127 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003128 */
Emeric Brun08622d32020-12-23 17:41:43 +01003129int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *counters)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003130{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003131 struct server *s = NULL;
Emeric Brun08622d32020-12-23 17:41:43 +01003132 struct resolv_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003133 void *serverip, *firstip;
3134 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003135 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003136 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003137 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003138
Christopher Faulet67957bd2017-09-27 11:00:59 +02003139 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003140 if (!s)
3141 return 1;
3142
Christopher Faulet49531e82021-03-10 15:07:27 +01003143 if (s->srvrq) {
3144 struct resolv_answer_item *srv_item;
3145
3146 /* If DNS resolution is disabled ignore it. */
3147 if (s->flags & SRV_F_NO_RESOLUTION)
3148 return 1;
3149
3150 /* The server is based on a SRV record, thus, find the
3151 * associated answer record. If not found, it means the SRV item
3152 * has expired and this resolution must be ignored.
3153 */
3154 srv_item = find_srvrq_answer_record(requester);
3155 if (!srv_item)
3156 return 1;
3157 }
3158
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003159 resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
Christopher Faulet49531e82021-03-10 15:07:27 +01003160 if (!resolution)
3161 return 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003162
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003163 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003164 firstip = NULL; /* pointer to the first valid response found */
3165 /* it will be used as the new IP if a change is required */
3166 firstip_sin_family = AF_UNSPEC;
3167 serverip = NULL; /* current server IP address */
3168
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003169 /* initializing server IP pointer */
3170 server_sin_family = s->addr.ss_family;
3171 switch (server_sin_family) {
3172 case AF_INET:
3173 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3174 break;
3175
3176 case AF_INET6:
3177 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3178 break;
3179
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003180 case AF_UNSPEC:
3181 break;
3182
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003183 default:
3184 goto invalid;
3185 }
3186
Emeric Brund30e9a12020-12-23 18:49:16 +01003187 ret = resolv_get_ip_from_response(&resolution->response, &s->resolv_opts,
3188 serverip, server_sin_family, &firstip,
3189 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003190
3191 switch (ret) {
Emeric Brun456de772020-12-23 18:17:31 +01003192 case RSLV_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003193 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003194
Emeric Brun456de772020-12-23 18:17:31 +01003195 case RSLV_UPD_SRVIP_NOT_FOUND:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003196 goto save_ip;
3197
Emeric Brun456de772020-12-23 18:17:31 +01003198 case RSLV_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003199 goto invalid;
3200
Emeric Brun456de772020-12-23 18:17:31 +01003201 case RSLV_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003202 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003203 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003204
Emeric Brun456de772020-12-23 18:17:31 +01003205 case RSLV_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003206 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003207 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003208 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003209
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003210 default:
3211 goto invalid;
3212
3213 }
3214
3215 save_ip:
Emeric Brun50c870e2021-01-04 10:40:46 +01003216 if (counters) {
3217 counters->update++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003218 /* save the first ip we found */
Emeric Brun50c870e2021-01-04 10:40:46 +01003219 chunk_printf(chk, "%s/%s", counters->pid, counters->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003220 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003221 else
3222 chunk_printf(chk, "DNS cache");
Christopher Faulet69beaa92021-02-16 12:07:47 +01003223 srv_update_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003224
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003225 update_status:
Christopher Faulet49531e82021-03-10 15:07:27 +01003226
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003227 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003228 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003229
3230 invalid:
Emeric Brun50c870e2021-01-04 10:40:46 +01003231 if (counters) {
3232 counters->invalid++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003233 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003234 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003235 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003236 return 0;
3237}
3238
3239/*
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003240 * SRV record error management callback
3241 * returns:
3242 * 0 on error
3243 * 1 when no error or safe ignore
3244 *
3245 * Grabs the server's lock.
3246 */
3247int srvrq_resolution_error_cb(struct resolv_requester *requester, int error_code)
3248{
3249 struct server *s;
3250 struct resolv_srvrq *srvrq;
3251 struct resolv_resolution *res;
3252 struct resolvers *resolvers;
3253 int exp;
3254
3255 /* SRV records */
3256 srvrq = objt_resolv_srvrq(requester->owner);
3257 if (!srvrq)
3258 return 1;
3259
3260 resolvers = srvrq->resolvers;
3261 res = requester->resolution;
3262
3263 switch (res->status) {
3264
3265 case RSLV_STATUS_NX:
3266 /* stop server if resolution is NX for a long enough period */
3267 exp = tick_add(res->last_valid, resolvers->hold.nx);
3268 if (!tick_is_expired(exp, now_ms))
3269 return 1;
3270 break;
3271
3272 case RSLV_STATUS_TIMEOUT:
3273 /* stop server if resolution is TIMEOUT for a long enough period */
3274 exp = tick_add(res->last_valid, resolvers->hold.timeout);
3275 if (!tick_is_expired(exp, now_ms))
3276 return 1;
3277 break;
3278
3279 case RSLV_STATUS_REFUSED:
3280 /* stop server if resolution is REFUSED for a long enough period */
3281 exp = tick_add(res->last_valid, resolvers->hold.refused);
3282 if (!tick_is_expired(exp, now_ms))
3283 return 1;
3284 break;
3285
3286 default:
3287 /* stop server if resolution failed for a long enough period */
3288 exp = tick_add(res->last_valid, resolvers->hold.other);
3289 if (!tick_is_expired(exp, now_ms))
3290 return 1;
3291 }
3292
3293 /* Remove any associated server */
3294 for (s = srvrq->proxy->srv; s != NULL; s = s->next) {
3295 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
3296 if (s->srvrq == srvrq) {
Christopher Faulet0efc0992021-03-11 18:09:53 +01003297 resolv_unlink_resolution(s->resolv_requester, 1);
Christopher Faulet6b117ae2021-03-11 18:06:23 +01003298 srvrq_update_srv_status(s, 1);
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003299 free(s->hostname);
3300 free(s->hostname_dn);
3301 s->hostname = NULL;
3302 s->hostname_dn = NULL;
3303 s->hostname_dn_len = 0;
Christopher Faulet52d4d302021-02-23 12:24:09 +01003304 memset(&s->addr, 0, sizeof(s->addr));
3305 s->svc_port = 0;
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003306 }
3307 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
3308 }
3309
Christopher Faulet51d5e3b2021-03-10 15:46:46 +01003310 resolv_purge_resolution_answer_records(res);
3311
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003312 return 1;
3313}
3314
3315/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003316 * Server Name Resolution error management callback
3317 * returns:
3318 * 0 on error
3319 * 1 when no error or safe ignore
Willy Tarreau46b7f532018-08-21 11:54:26 +02003320 *
3321 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003322 */
Emeric Brun08622d32020-12-23 17:41:43 +01003323int snr_resolution_error_cb(struct resolv_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003324{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003325 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003326
Christopher Faulet67957bd2017-09-27 11:00:59 +02003327 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003328 if (!s)
3329 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003330 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Christopher Faulet5130c212021-03-10 20:31:40 +01003331 if (!snr_update_srv_status(s, 1))
3332 memset(&s->addr, 0, sizeof(s->addr));
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003333 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003334 return 1;
3335}
3336
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003337/*
3338 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003339 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003340 * It returns a pointer to the first server found or NULL if <ip> is not yet
3341 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003342 *
3343 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003344 */
3345struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3346{
3347 struct server *tmpsrv;
3348 struct proxy *be;
3349
3350 if (!srv)
3351 return NULL;
3352
3353 be = srv->proxy;
3354 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003355 /* we found the current server is the same, ignore it */
3356 if (srv == tmpsrv)
3357 continue;
3358
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003359 /* We want to compare the IP in the record with the IP of the servers in the
3360 * same backend, only if:
3361 * * DNS resolution is enabled on the server
3362 * * the hostname used for the resolution by our server is the same than the
3363 * one used for the server found in the backend
3364 * * the server found in the backend is not our current server
3365 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003366 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003367 if ((tmpsrv->hostname_dn == NULL) ||
3368 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
3369 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01003370 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003371 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003372 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003373 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003374
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003375 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01003376 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003377 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003378 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003379 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003380
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003381 /* At this point, we have 2 different servers using the same DNS hostname
3382 * for their respective resolution.
3383 */
3384 if (*ip_family == tmpsrv->addr.ss_family &&
3385 ((tmpsrv->addr.ss_family == AF_INET &&
3386 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3387 (tmpsrv->addr.ss_family == AF_INET6 &&
3388 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003389 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003390 return tmpsrv;
3391 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003392 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003393 }
3394
Emeric Brune9fd6b52017-11-02 17:20:39 +01003395
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003396 return NULL;
3397}
3398
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003399/* Sets the server's address (srv->addr) from srv->hostname using the libc's
3400 * resolver. This is suited for initial address configuration. Returns 0 on
3401 * success otherwise a non-zero error code. In case of error, *err_code, if
3402 * not NULL, is filled up.
3403 */
3404int srv_set_addr_via_libc(struct server *srv, int *err_code)
3405{
3406 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003407 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01003408 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003409 return 1;
3410 }
3411 return 0;
3412}
3413
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003414/* Set the server's FDQN (->hostname) from <hostname>.
3415 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003416 *
3417 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003418 */
Emeric Brun08622d32020-12-23 17:41:43 +01003419int srv_set_fqdn(struct server *srv, const char *hostname, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003420{
Emeric Brun08622d32020-12-23 17:41:43 +01003421 struct resolv_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003422 char *hostname_dn;
3423 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003424
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02003425 /* Note that the server lock is already held. */
3426 if (!srv->resolvers)
3427 return -1;
3428
Emeric Brun08622d32020-12-23 17:41:43 +01003429 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003430 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003431 /* run time DNS/SRV resolution was not active for this server
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003432 * and we can't enable it at run time for now.
3433 */
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003434 if (!srv->resolv_requester && !srv->srvrq)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003435 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003436
3437 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003438 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003439 hostname_dn = trash.area;
Emeric Brund30e9a12020-12-23 18:49:16 +01003440 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len + 1,
3441 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003442 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003443 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003444
Christopher Fauletd83a6df2021-03-12 10:23:05 +01003445 resolution = (srv->resolv_requester ? srv->resolv_requester->resolution : NULL);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003446 if (resolution &&
3447 resolution->hostname_dn &&
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003448 strcmp(resolution->hostname_dn, hostname_dn) == 0)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003449 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003450
Christopher Faulet0efc0992021-03-11 18:09:53 +01003451 resolv_unlink_resolution(srv->resolv_requester, 0);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003452
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003453 free(srv->hostname);
3454 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003455 srv->hostname = strdup(hostname);
3456 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003457 srv->hostname_dn_len = hostname_dn_len;
3458 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003459 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003460
Baptiste Assmann13a92322019-06-07 09:40:55 +02003461 if (srv->flags & SRV_F_NO_RESOLUTION)
3462 goto end;
3463
Emeric Brund30e9a12020-12-23 18:49:16 +01003464 if (resolv_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003465 goto err;
3466
3467 end:
Emeric Brun08622d32020-12-23 17:41:43 +01003468 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003469 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003470 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02003471
3472 err:
Emeric Brun08622d32020-12-23 17:41:43 +01003473 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003474 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02003475 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003476}
3477
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003478/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
3479 * from the state file. This is suited for initial address configuration.
3480 * Returns 0 on success otherwise a non-zero error code. In case of error,
3481 * *err_code, if not NULL, is filled up.
3482 */
3483static int srv_apply_lastaddr(struct server *srv, int *err_code)
3484{
3485 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
3486 if (err_code)
3487 *err_code |= ERR_WARN;
3488 return 1;
3489 }
3490 return 0;
3491}
3492
Willy Tarreau25e51522016-11-04 15:10:17 +01003493/* returns 0 if no error, otherwise a combination of ERR_* flags */
3494static int srv_iterate_initaddr(struct server *srv)
3495{
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003496 char *name = srv->hostname;
Willy Tarreau25e51522016-11-04 15:10:17 +01003497 int return_code = 0;
3498 int err_code;
3499 unsigned int methods;
3500
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003501 /* If no addr and no hostname set, get the name from the DNS SRV request */
3502 if (!name && srv->srvrq)
3503 name = srv->srvrq->name;
3504
Willy Tarreau25e51522016-11-04 15:10:17 +01003505 methods = srv->init_addr_methods;
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003506 if (!methods) {
3507 /* otherwise default to "last,libc" */
Willy Tarreau25e51522016-11-04 15:10:17 +01003508 srv_append_initaddr(&methods, SRV_IADDR_LAST);
3509 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003510 if (srv->resolvers_id) {
3511 /* dns resolution is configured, add "none" to not fail on startup */
3512 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3513 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003514 }
3515
Willy Tarreau3eed10e2016-11-07 21:03:16 +01003516 /* "-dr" : always append "none" so that server addresses resolution
3517 * failures are silently ignored, this is convenient to validate some
3518 * configs out of their environment.
3519 */
3520 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
3521 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3522
Willy Tarreau25e51522016-11-04 15:10:17 +01003523 while (methods) {
3524 err_code = 0;
3525 switch (srv_get_next_initaddr(&methods)) {
3526 case SRV_IADDR_LAST:
3527 if (!srv->lastaddr)
3528 continue;
3529 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003530 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003531 return_code |= err_code;
3532 break;
3533
3534 case SRV_IADDR_LIBC:
3535 if (!srv->hostname)
3536 continue;
3537 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003538 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003539 return_code |= err_code;
3540 break;
3541
Willy Tarreau37ebe122016-11-04 15:17:58 +01003542 case SRV_IADDR_NONE:
3543 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003544 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003545 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003546 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003547 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01003548 return return_code;
3549
Willy Tarreau4310d362016-11-02 15:05:56 +01003550 case SRV_IADDR_IP:
3551 ipcpy(&srv->init_addr, &srv->addr);
3552 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003553 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 +01003554 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau4310d362016-11-02 15:05:56 +01003555 }
Olivier Houchard4e694042017-03-14 20:01:29 +01003556 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01003557
Willy Tarreau25e51522016-11-04 15:10:17 +01003558 default: /* unhandled method */
3559 break;
3560 }
3561 }
3562
3563 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003564 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003565 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau25e51522016-11-04 15:10:17 +01003566 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01003567 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003568 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003569 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003570 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003571
3572 return_code |= ERR_ALERT | ERR_FATAL;
3573 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01003574out:
3575 srv_set_dyncookie(srv);
Thayne McCombs92149f92020-11-20 01:28:26 -07003576 srv_set_addr_desc(srv);
Olivier Houchard4e694042017-03-14 20:01:29 +01003577 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01003578}
3579
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003580/*
3581 * This function parses all backends and all servers within each backend
3582 * and performs servers' addr resolution based on information provided by:
3583 * - configuration file
3584 * - server-state file (states provided by an 'old' haproxy process)
3585 *
3586 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
3587 */
3588int srv_init_addr(void)
3589{
3590 struct proxy *curproxy;
3591 int return_code = 0;
3592
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003593 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003594 while (curproxy) {
3595 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003596
3597 /* servers are in backend only */
Amaury Denoyellee3c41922021-01-06 14:28:50 +01003598 if (!(curproxy->cap & PR_CAP_BE) || curproxy->disabled)
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003599 goto srv_init_addr_next;
3600
Willy Tarreau25e51522016-11-04 15:10:17 +01003601 for (srv = curproxy->srv; srv; srv = srv->next)
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003602 if (srv->hostname || srv->srvrq)
Willy Tarreau3d609a72017-09-06 14:22:45 +02003603 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003604
3605 srv_init_addr_next:
3606 curproxy = curproxy->next;
3607 }
3608
3609 return return_code;
3610}
3611
Willy Tarreau46b7f532018-08-21 11:54:26 +02003612/*
3613 * Must be called with the server lock held.
3614 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003615const 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 +02003616{
3617
Willy Tarreau83061a82018-07-13 11:56:34 +02003618 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003619
3620 msg = get_trash_chunk();
3621 chunk_reset(msg);
3622
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003623 if (server->hostname && strcmp(fqdn, server->hostname) == 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003624 chunk_appendf(msg, "no need to change the FDQN");
3625 goto out;
3626 }
3627
3628 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
3629 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
3630 goto out;
3631 }
3632
3633 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
3634 server->proxy->id, server->id, server->hostname, fqdn);
3635
Emeric Brun08622d32020-12-23 17:41:43 +01003636 if (srv_set_fqdn(server, fqdn, resolv_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003637 chunk_reset(msg);
3638 chunk_appendf(msg, "could not update %s/%s FQDN",
3639 server->proxy->id, server->id);
3640 goto out;
3641 }
3642
3643 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02003644 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003645
3646 out:
3647 if (updater)
3648 chunk_appendf(msg, " by '%s'", updater);
3649 chunk_appendf(msg, "\n");
3650
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003651 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003652}
3653
3654
Willy Tarreau21b069d2016-11-23 17:15:08 +01003655/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
3656 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01003657 * 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 +01003658 * used for CLI commands requiring a server name.
3659 * Important: the <arg> is modified to remove the '/'.
3660 */
3661struct server *cli_find_server(struct appctx *appctx, char *arg)
3662{
3663 struct proxy *px;
3664 struct server *sv;
3665 char *line;
3666
3667 /* split "backend/server" and make <line> point to server */
3668 for (line = arg; *line; line++)
3669 if (*line == '/') {
3670 *line++ = '\0';
3671 break;
3672 }
3673
3674 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003675 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003676 return NULL;
3677 }
3678
3679 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003680 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003681 return NULL;
3682 }
3683
Willy Tarreauc3914d42020-09-24 08:39:22 +02003684 if (px->disabled) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003685 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003686 return NULL;
3687 }
3688
3689 return sv;
3690}
3691
William Lallemand222baf22016-11-19 02:00:33 +01003692
Willy Tarreau46b7f532018-08-21 11:54:26 +02003693/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003694static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01003695{
3696 struct server *sv;
3697 const char *warning;
3698
3699 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3700 return 1;
3701
3702 sv = cli_find_server(appctx, args[2]);
3703 if (!sv)
3704 return 1;
3705
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003706 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02003707
William Lallemand222baf22016-11-19 02:00:33 +01003708 if (strcmp(args[3], "weight") == 0) {
3709 warning = server_parse_weight_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02003710 if (warning)
3711 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01003712 }
3713 else if (strcmp(args[3], "state") == 0) {
3714 if (strcmp(args[4], "ready") == 0)
3715 srv_adm_set_ready(sv);
3716 else if (strcmp(args[4], "drain") == 0)
3717 srv_adm_set_drain(sv);
3718 else if (strcmp(args[4], "maint") == 0)
3719 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02003720 else
3721 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003722 }
3723 else if (strcmp(args[3], "health") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003724 if (sv->track)
3725 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003726 else if (strcmp(args[4], "up") == 0) {
3727 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003728 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003729 }
3730 else if (strcmp(args[4], "stopping") == 0) {
3731 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003732 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003733 }
3734 else if (strcmp(args[4], "down") == 0) {
3735 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02003736 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003737 }
Willy Tarreau9d008692019-08-09 11:21:01 +02003738 else
3739 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003740 }
3741 else if (strcmp(args[3], "agent") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003742 if (!(sv->agent.state & CHK_ST_ENABLED))
3743 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003744 else if (strcmp(args[4], "up") == 0) {
3745 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003746 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003747 }
3748 else if (strcmp(args[4], "down") == 0) {
3749 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02003750 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003751 }
Willy Tarreau9d008692019-08-09 11:21:01 +02003752 else
3753 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003754 }
Misiek2da082d2017-01-09 09:40:42 +01003755 else if (strcmp(args[3], "agent-addr") == 0) {
William Dauchy7cabc062021-02-11 22:51:24 +01003756 char *addr = NULL;
3757 char *port = NULL;
3758 if (strlen(args[4]) == 0) {
3759 cli_err(appctx, "set server <b>/<s> agent-addr requires"
3760 " an address and optionally a port.\n");
3761 goto out_unlock;
3762 }
3763 addr = args[4];
3764 if (strcmp(args[5], "port") == 0)
3765 port = args[6];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003766 warning = srv_update_agent_addr_port(sv, addr, port);
William Dauchy7cabc062021-02-11 22:51:24 +01003767 if (warning)
3768 cli_msg(appctx, LOG_WARNING, warning);
3769 }
3770 else if (strcmp(args[3], "agent-port") == 0) {
3771 char *port = NULL;
3772 if (strlen(args[4]) == 0) {
3773 cli_err(appctx, "set server <b>/<s> agent-port requires"
3774 " a port.\n");
3775 goto out_unlock;
3776 }
3777 port = args[4];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003778 warning = srv_update_agent_addr_port(sv, NULL, port);
William Dauchy7cabc062021-02-11 22:51:24 +01003779 if (warning)
3780 cli_msg(appctx, LOG_WARNING, warning);
Misiek2da082d2017-01-09 09:40:42 +01003781 }
3782 else if (strcmp(args[3], "agent-send") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003783 if (!(sv->agent.state & CHK_ST_ENABLED))
3784 cli_err(appctx, "agent checks are not enabled on this server.\n");
3785 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02003786 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02003787 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01003788 }
3789 }
William Dauchyb456e1f2021-02-11 22:51:23 +01003790 else if (strcmp(args[3], "check-addr") == 0) {
3791 char *addr = NULL;
3792 char *port = NULL;
3793 if (strlen(args[4]) == 0) {
3794 cli_err(appctx, "set server <b>/<s> check-addr requires"
3795 " an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003796 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01003797 }
William Dauchyb456e1f2021-02-11 22:51:23 +01003798 addr = args[4];
3799 if (strcmp(args[5], "port") == 0)
3800 port = args[6];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003801 warning = srv_update_check_addr_port(sv, addr, port);
William Dauchyb456e1f2021-02-11 22:51:23 +01003802 if (warning)
3803 cli_msg(appctx, LOG_WARNING, warning);
3804 }
3805 else if (strcmp(args[3], "check-port") == 0) {
3806 char *port = NULL;
3807 if (strlen(args[4]) == 0) {
3808 cli_err(appctx, "set server <b>/<s> check-port requires"
3809 " a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003810 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01003811 }
William Dauchyb456e1f2021-02-11 22:51:23 +01003812 port = args[4];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003813 warning = srv_update_check_addr_port(sv, NULL, port);
William Dauchyb456e1f2021-02-11 22:51:23 +01003814 if (warning)
3815 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01003816 }
3817 else if (strcmp(args[3], "addr") == 0) {
3818 char *addr = NULL;
3819 char *port = NULL;
3820 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003821 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003822 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01003823 }
3824 else {
3825 addr = args[4];
3826 }
3827 if (strcmp(args[5], "port") == 0) {
3828 port = args[6];
3829 }
Christopher Faulet69beaa92021-02-16 12:07:47 +01003830 warning = srv_update_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02003831 if (warning)
3832 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01003833 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
3834 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003835 else if (strcmp(args[3], "fqdn") == 0) {
3836 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003837 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003838 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003839 }
Baptiste Assmann13a92322019-06-07 09:40:55 +02003840 /* ensure runtime resolver will process this new fqdn */
3841 if (sv->flags & SRV_F_NO_RESOLUTION) {
3842 sv->flags &= ~SRV_F_NO_RESOLUTION;
3843 }
Christopher Faulet69beaa92021-02-16 12:07:47 +01003844 warning = srv_update_fqdn(sv, args[4], "stats socket command", 0);
Willy Tarreau9d008692019-08-09 11:21:01 +02003845 if (warning)
3846 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003847 }
William Dauchyf6370442020-11-14 19:25:33 +01003848 else if (strcmp(args[3], "ssl") == 0) {
3849#ifdef USE_OPENSSL
3850 if (sv->ssl_ctx.ctx == NULL) {
3851 cli_err(appctx, "'set server <srv> ssl' cannot be set. "
3852 " default-server should define ssl settings\n");
3853 goto out_unlock;
3854 } else if (strcmp(args[4], "on") == 0) {
3855 ssl_sock_set_srv(sv, 1);
3856 } else if (strcmp(args[4], "off") == 0) {
3857 ssl_sock_set_srv(sv, 0);
3858 } else {
3859 cli_err(appctx, "'set server <srv> ssl' expects 'on' or 'off'.\n");
3860 goto out_unlock;
3861 }
3862 srv_cleanup_connections(sv);
3863 cli_msg(appctx, LOG_NOTICE, "server ssl setting updated.\n");
3864#else
3865 cli_msg(appctx, LOG_NOTICE, "server ssl setting not supported.\n");
3866#endif
3867 } else {
Willy Tarreau9d008692019-08-09 11:21:01 +02003868 cli_err(appctx,
William Dauchy3f4ec7d2021-02-15 17:22:16 +01003869 "usage: set server <backend>/<server> "
3870 "addr | agent | agent-addr | agent-port | agent-send | "
3871 "check-addr | check-port | fqdn | health | ssl | "
3872 "state | weight\n");
William Lallemand222baf22016-11-19 02:00:33 +01003873 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003874 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003875 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01003876 return 1;
3877}
3878
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003879static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01003880{
3881 struct stream_interface *si = appctx->owner;
3882 struct proxy *px;
3883 struct server *sv;
3884 char *line;
3885
3886
3887 /* split "backend/server" and make <line> point to server */
3888 for (line = args[2]; *line; line++)
3889 if (*line == '/') {
3890 *line++ = '\0';
3891 break;
3892 }
3893
Willy Tarreau9d008692019-08-09 11:21:01 +02003894 if (!*line)
3895 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01003896
Willy Tarreau9d008692019-08-09 11:21:01 +02003897 if (!get_backend_server(args[2], line, &px, &sv))
3898 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01003899
3900 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003901 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
3902 sv->iweight);
3903 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01003904 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01003905 return 0;
3906 }
William Lallemand6b160942016-11-22 12:34:35 +01003907 return 1;
3908}
3909
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003910/* Parse a "set weight" command.
3911 *
3912 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003913 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003914static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01003915{
3916 struct server *sv;
3917 const char *warning;
3918
3919 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3920 return 1;
3921
3922 sv = cli_find_server(appctx, args[2]);
3923 if (!sv)
3924 return 1;
3925
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003926 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
3927
William Lallemand6b160942016-11-22 12:34:35 +01003928 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02003929 if (warning)
3930 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003931
3932 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
3933
William Lallemand6b160942016-11-22 12:34:35 +01003934 return 1;
3935}
3936
Willy Tarreau46b7f532018-08-21 11:54:26 +02003937/* parse a "set maxconn server" command. It always returns 1.
3938 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003939 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003940 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003941static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01003942{
3943 struct server *sv;
3944 const char *warning;
3945
3946 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3947 return 1;
3948
3949 sv = cli_find_server(appctx, args[3]);
3950 if (!sv)
3951 return 1;
3952
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003953 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
3954
Willy Tarreaub8026272016-11-23 11:26:56 +01003955 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02003956 if (warning)
3957 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003958
3959 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
3960
Willy Tarreaub8026272016-11-23 11:26:56 +01003961 return 1;
3962}
William Lallemand6b160942016-11-22 12:34:35 +01003963
Willy Tarreau46b7f532018-08-21 11:54:26 +02003964/* parse a "disable agent" command. It always returns 1.
3965 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003966 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003967 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003968static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003969{
3970 struct server *sv;
3971
3972 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3973 return 1;
3974
3975 sv = cli_find_server(appctx, args[2]);
3976 if (!sv)
3977 return 1;
3978
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003979 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003980 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003981 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003982 return 1;
3983}
3984
Willy Tarreau46b7f532018-08-21 11:54:26 +02003985/* parse a "disable health" command. It always returns 1.
3986 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003987 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003988 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003989static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01003990{
3991 struct server *sv;
3992
3993 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3994 return 1;
3995
3996 sv = cli_find_server(appctx, args[2]);
3997 if (!sv)
3998 return 1;
3999
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004000 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004001 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004002 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004003 return 1;
4004}
4005
Willy Tarreau46b7f532018-08-21 11:54:26 +02004006/* parse a "disable server" command. It always returns 1.
4007 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004008 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004009 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004010static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004011{
4012 struct server *sv;
4013
4014 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4015 return 1;
4016
4017 sv = cli_find_server(appctx, args[2]);
4018 if (!sv)
4019 return 1;
4020
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004021 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004022 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004023 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004024 return 1;
4025}
4026
Willy Tarreau46b7f532018-08-21 11:54:26 +02004027/* parse a "enable agent" command. It always returns 1.
4028 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004029 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004030 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004031static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004032{
4033 struct server *sv;
4034
4035 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4036 return 1;
4037
4038 sv = cli_find_server(appctx, args[2]);
4039 if (!sv)
4040 return 1;
4041
Willy Tarreau9d008692019-08-09 11:21:01 +02004042 if (!(sv->agent.state & CHK_ST_CONFIGURED))
4043 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004044
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004045 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004046 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004047 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004048 return 1;
4049}
4050
Willy Tarreau46b7f532018-08-21 11:54:26 +02004051/* parse a "enable health" command. It always returns 1.
4052 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004053 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004054 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004055static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004056{
4057 struct server *sv;
4058
4059 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4060 return 1;
4061
4062 sv = cli_find_server(appctx, args[2]);
4063 if (!sv)
4064 return 1;
4065
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004066 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004067 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004068 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004069 return 1;
4070}
4071
Willy Tarreau46b7f532018-08-21 11:54:26 +02004072/* parse a "enable server" command. It always returns 1.
4073 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004074 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004075 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004076static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004077{
4078 struct server *sv;
4079
4080 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4081 return 1;
4082
4083 sv = cli_find_server(appctx, args[2]);
4084 if (!sv)
4085 return 1;
4086
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004087 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004088 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004089 if (!(sv->flags & SRV_F_COOKIESET)
4090 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4091 sv->cookie)
4092 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004093 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004094 return 1;
4095}
4096
William Lallemand222baf22016-11-19 02:00:33 +01004097/* register cli keywords */
4098static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004099 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004100 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004101 { { "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 +01004102 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004103 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004104 { { "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 +01004105 { { "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 +01004106 { { "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 +01004107 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4108 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4109
William Lallemand222baf22016-11-19 02:00:33 +01004110 {{},}
4111}};
4112
Willy Tarreau0108d902018-11-25 19:14:37 +01004113INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004114
Emeric Brun64cc49c2017-10-03 14:46:45 +02004115/*
4116 * This function applies server's status changes, it is
4117 * is designed to be called asynchronously.
4118 *
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004119 * Must be called with the server lock held. This may also be called at init
4120 * time as the result of parsing the state file, in which case no lock will be
4121 * held, and the server's warmup task can be null.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004122 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004123static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004124{
4125 struct check *check = &s->check;
4126 int xferred;
4127 struct proxy *px = s->proxy;
4128 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4129 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4130 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004131 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004132
Emeric Brun64cc49c2017-10-03 14:46:45 +02004133 /* If currently main is not set we try to apply pending state changes */
4134 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4135 int next_admin;
4136
4137 /* Backup next admin */
4138 next_admin = s->next_admin;
4139
4140 /* restore current admin state */
4141 s->next_admin = s->cur_admin;
4142
4143 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4144 s->last_change = now.tv_sec;
4145 if (s->proxy->lbprm.set_server_status_down)
4146 s->proxy->lbprm.set_server_status_down(s);
4147
4148 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4149 srv_shutdown_streams(s, SF_ERR_DOWN);
4150
4151 /* we might have streams queued on this server and waiting for
4152 * a connection. Those which are redispatchable will be queued
4153 * to another server or to the proxy itself.
4154 */
4155 xferred = pendconn_redistribute(s);
4156
4157 tmptrash = alloc_trash_chunk();
4158 if (tmptrash) {
4159 chunk_printf(tmptrash,
4160 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4161 s->proxy->id, s->id);
4162
Emeric Brun5a133512017-10-19 14:42:30 +02004163 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004164 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004165
4166 /* we don't send an alert if the server was previously paused */
4167 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004168 send_log(s->proxy, log_level, "%s.\n",
4169 tmptrash->area);
4170 send_email_alert(s, log_level, "%s",
4171 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004172 free_trash_chunk(tmptrash);
4173 tmptrash = NULL;
4174 }
4175 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4176 set_backend_down(s->proxy);
4177
4178 s->counters.down_trans++;
4179 }
4180 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4181 s->last_change = now.tv_sec;
4182 if (s->proxy->lbprm.set_server_status_down)
4183 s->proxy->lbprm.set_server_status_down(s);
4184
4185 /* we might have streams queued on this server and waiting for
4186 * a connection. Those which are redispatchable will be queued
4187 * to another server or to the proxy itself.
4188 */
4189 xferred = pendconn_redistribute(s);
4190
4191 tmptrash = alloc_trash_chunk();
4192 if (tmptrash) {
4193 chunk_printf(tmptrash,
4194 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4195 s->proxy->id, s->id);
4196
Emeric Brun5a133512017-10-19 14:42:30 +02004197 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004198
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004199 ha_warning("%s.\n", tmptrash->area);
4200 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4201 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004202 free_trash_chunk(tmptrash);
4203 tmptrash = NULL;
4204 }
4205
4206 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4207 set_backend_down(s->proxy);
4208 }
4209 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4210 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4211 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4212 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4213 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4214 s->proxy->last_change = now.tv_sec;
4215 }
4216
Amaury Denoyellefe2bf092020-10-29 15:59:04 +01004217 if (s->cur_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
Emeric Brun64cc49c2017-10-03 14:46:45 +02004218 s->down_time += now.tv_sec - s->last_change;
4219
4220 s->last_change = now.tv_sec;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004221 if (s->next_state == SRV_ST_STARTING && s->warmup)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004222 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4223
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004224 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004225 /* now propagate the status change to any LB algorithms */
4226 if (px->lbprm.update_server_eweight)
4227 px->lbprm.update_server_eweight(s);
4228 else if (srv_willbe_usable(s)) {
4229 if (px->lbprm.set_server_status_up)
4230 px->lbprm.set_server_status_up(s);
4231 }
4232 else {
4233 if (px->lbprm.set_server_status_down)
4234 px->lbprm.set_server_status_down(s);
4235 }
4236
4237 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4238 * and it's not a backup server and its effective weight is > 0,
4239 * then it can accept new connections, so we shut down all streams
4240 * on all backup servers.
4241 */
4242 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4243 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4244 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4245
4246 /* check if we can handle some connections queued at the proxy. We
4247 * will take as many as we can handle.
4248 */
4249 xferred = pendconn_grab_from_px(s);
4250
4251 tmptrash = alloc_trash_chunk();
4252 if (tmptrash) {
4253 chunk_printf(tmptrash,
4254 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4255 s->proxy->id, s->id);
4256
Emeric Brun5a133512017-10-19 14:42:30 +02004257 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004258 ha_warning("%s.\n", tmptrash->area);
4259 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4260 tmptrash->area);
4261 send_email_alert(s, LOG_NOTICE, "%s",
4262 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004263 free_trash_chunk(tmptrash);
4264 tmptrash = NULL;
4265 }
4266
4267 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4268 set_backend_down(s->proxy);
4269 }
4270 else if (s->cur_eweight != s->next_eweight) {
4271 /* now propagate the status change to any LB algorithms */
4272 if (px->lbprm.update_server_eweight)
4273 px->lbprm.update_server_eweight(s);
4274 else if (srv_willbe_usable(s)) {
4275 if (px->lbprm.set_server_status_up)
4276 px->lbprm.set_server_status_up(s);
4277 }
4278 else {
4279 if (px->lbprm.set_server_status_down)
4280 px->lbprm.set_server_status_down(s);
4281 }
4282
4283 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4284 set_backend_down(s->proxy);
4285 }
4286
4287 s->next_admin = next_admin;
4288 }
4289
Emeric Brun5a133512017-10-19 14:42:30 +02004290 /* reset operational state change */
4291 *s->op_st_chg.reason = 0;
4292 s->op_st_chg.status = s->op_st_chg.code = -1;
4293 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004294
4295 /* Now we try to apply pending admin changes */
4296
4297 /* Maintenance must also disable health checks */
4298 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4299 if (s->check.state & CHK_ST_ENABLED) {
4300 s->check.state |= CHK_ST_PAUSED;
4301 check->health = 0;
4302 }
4303
4304 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004305 tmptrash = alloc_trash_chunk();
4306 if (tmptrash) {
4307 chunk_printf(tmptrash,
4308 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4309 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4310 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004311
Olivier Houchard796a2b32017-10-24 17:42:47 +02004312 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004313
Olivier Houchard796a2b32017-10-24 17:42:47 +02004314 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004315 ha_warning("%s.\n", tmptrash->area);
4316 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4317 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004318 }
4319 free_trash_chunk(tmptrash);
4320 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004321 }
Emeric Brun8f298292017-12-06 16:47:17 +01004322 /* commit new admin status */
4323
4324 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004325 }
4326 else { /* server was still running */
4327 check->health = 0; /* failure */
4328 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004329
4330 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004331 if (s->proxy->lbprm.set_server_status_down)
4332 s->proxy->lbprm.set_server_status_down(s);
4333
Emeric Brun64cc49c2017-10-03 14:46:45 +02004334 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4335 srv_shutdown_streams(s, SF_ERR_DOWN);
4336
William Dauchy6318d332020-05-02 21:52:36 +02004337 /* force connection cleanup on the given server */
4338 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004339 /* we might have streams queued on this server and waiting for
4340 * a connection. Those which are redispatchable will be queued
4341 * to another server or to the proxy itself.
4342 */
4343 xferred = pendconn_redistribute(s);
4344
4345 tmptrash = alloc_trash_chunk();
4346 if (tmptrash) {
4347 chunk_printf(tmptrash,
4348 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
4349 s->flags & SRV_F_BACKUP ? "Backup " : "",
4350 s->proxy->id, s->id,
4351 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4352
4353 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
4354
4355 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004356 ha_warning("%s.\n", tmptrash->area);
4357 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
4358 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004359 }
4360 free_trash_chunk(tmptrash);
4361 tmptrash = NULL;
4362 }
4363 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4364 set_backend_down(s->proxy);
4365
4366 s->counters.down_trans++;
4367 }
4368 }
4369 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
4370 /* OK here we're leaving maintenance, we have many things to check,
4371 * because the server might possibly be coming back up depending on
4372 * its state. In practice, leaving maintenance means that we should
4373 * immediately turn to UP (more or less the slowstart) under the
4374 * following conditions :
4375 * - server is neither checked nor tracked
4376 * - server tracks another server which is not checked
4377 * - server tracks another server which is already up
4378 * Which sums up as something simpler :
4379 * "either the tracking server is up or the server's checks are disabled
4380 * or up". Otherwise we only re-enable health checks. There's a special
4381 * case associated to the stopping state which can be inherited. Note
4382 * that the server might still be in drain mode, which is naturally dealt
4383 * with by the lower level functions.
4384 */
4385
4386 if (s->check.state & CHK_ST_ENABLED) {
4387 s->check.state &= ~CHK_ST_PAUSED;
4388 check->health = check->rise; /* start OK but check immediately */
4389 }
4390
4391 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
4392 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
4393 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
4394 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
4395 s->next_state = SRV_ST_STOPPING;
4396 }
4397 else {
4398 s->next_state = SRV_ST_STARTING;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004399 if (s->slowstart > 0) {
4400 if (s->warmup)
4401 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4402 }
Emeric Brun64cc49c2017-10-03 14:46:45 +02004403 else
4404 s->next_state = SRV_ST_RUNNING;
4405 }
4406
4407 }
4408
4409 tmptrash = alloc_trash_chunk();
4410 if (tmptrash) {
4411 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4412 chunk_printf(tmptrash,
4413 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
4414 s->flags & SRV_F_BACKUP ? "Backup " : "",
4415 s->proxy->id, s->id,
4416 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4417 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4418 }
4419 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4420 chunk_printf(tmptrash,
4421 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
4422 s->flags & SRV_F_BACKUP ? "Backup " : "",
4423 s->proxy->id, s->id, s->hostname,
4424 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4425 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4426 }
4427 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4428 chunk_printf(tmptrash,
4429 "%sServer %s/%s is %s/%s (leaving maintenance)",
4430 s->flags & SRV_F_BACKUP ? "Backup " : "",
4431 s->proxy->id, s->id,
4432 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4433 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4434 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004435 ha_warning("%s.\n", tmptrash->area);
4436 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4437 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004438 free_trash_chunk(tmptrash);
4439 tmptrash = NULL;
4440 }
4441
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004442 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004443 /* now propagate the status change to any LB algorithms */
4444 if (px->lbprm.update_server_eweight)
4445 px->lbprm.update_server_eweight(s);
4446 else if (srv_willbe_usable(s)) {
4447 if (px->lbprm.set_server_status_up)
4448 px->lbprm.set_server_status_up(s);
4449 }
4450 else {
4451 if (px->lbprm.set_server_status_down)
4452 px->lbprm.set_server_status_down(s);
4453 }
4454
4455 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4456 set_backend_down(s->proxy);
4457
Willy Tarreau6a78e612018-08-07 10:14:53 +02004458 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4459 * and it's not a backup server and its effective weight is > 0,
4460 * then it can accept new connections, so we shut down all streams
4461 * on all backup servers.
4462 */
4463 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4464 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4465 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4466
4467 /* check if we can handle some connections queued at the proxy. We
4468 * will take as many as we can handle.
4469 */
4470 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004471 }
4472 else if (s->next_admin & SRV_ADMF_MAINT) {
4473 /* remaining in maintenance mode, let's inform precisely about the
4474 * situation.
4475 */
4476 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4477 tmptrash = alloc_trash_chunk();
4478 if (tmptrash) {
4479 chunk_printf(tmptrash,
4480 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
4481 s->flags & SRV_F_BACKUP ? "Backup " : "",
4482 s->proxy->id, s->id);
4483
4484 if (s->track) /* normally it's mandatory here */
4485 chunk_appendf(tmptrash, " via %s/%s",
4486 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004487 ha_warning("%s.\n", tmptrash->area);
4488 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4489 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004490 free_trash_chunk(tmptrash);
4491 tmptrash = NULL;
4492 }
4493 }
4494 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4495 tmptrash = alloc_trash_chunk();
4496 if (tmptrash) {
4497 chunk_printf(tmptrash,
4498 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
4499 s->flags & SRV_F_BACKUP ? "Backup " : "",
4500 s->proxy->id, s->id, s->hostname);
4501
4502 if (s->track) /* normally it's mandatory here */
4503 chunk_appendf(tmptrash, " via %s/%s",
4504 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004505 ha_warning("%s.\n", tmptrash->area);
4506 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4507 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004508 free_trash_chunk(tmptrash);
4509 tmptrash = NULL;
4510 }
4511 }
4512 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4513 tmptrash = alloc_trash_chunk();
4514 if (tmptrash) {
4515 chunk_printf(tmptrash,
4516 "%sServer %s/%s remains in forced maintenance",
4517 s->flags & SRV_F_BACKUP ? "Backup " : "",
4518 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004519 ha_warning("%s.\n", tmptrash->area);
4520 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4521 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004522 free_trash_chunk(tmptrash);
4523 tmptrash = NULL;
4524 }
4525 }
4526 /* don't report anything when leaving drain mode and remaining in maintenance */
4527
4528 s->cur_admin = s->next_admin;
4529 }
4530
4531 if (!(s->next_admin & SRV_ADMF_MAINT)) {
4532 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
4533 /* drain state is applied only if not yet in maint */
4534
4535 s->last_change = now.tv_sec;
4536 if (px->lbprm.set_server_status_down)
4537 px->lbprm.set_server_status_down(s);
4538
4539 /* we might have streams queued on this server and waiting for
4540 * a connection. Those which are redispatchable will be queued
4541 * to another server or to the proxy itself.
4542 */
4543 xferred = pendconn_redistribute(s);
4544
4545 tmptrash = alloc_trash_chunk();
4546 if (tmptrash) {
4547 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
4548 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4549 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4550
4551 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
4552
4553 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004554 ha_warning("%s.\n", tmptrash->area);
4555 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4556 tmptrash->area);
4557 send_email_alert(s, LOG_NOTICE, "%s",
4558 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004559 }
4560 free_trash_chunk(tmptrash);
4561 tmptrash = NULL;
4562 }
4563
4564 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4565 set_backend_down(s->proxy);
4566 }
4567 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
4568 /* OK completely leaving drain mode */
4569 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4570 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4571 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4572 s->proxy->last_change = now.tv_sec;
4573 }
4574
4575 if (s->last_change < now.tv_sec) // ignore negative times
4576 s->down_time += now.tv_sec - s->last_change;
4577 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004578 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004579
4580 tmptrash = alloc_trash_chunk();
4581 if (tmptrash) {
4582 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
4583 chunk_printf(tmptrash,
4584 "%sServer %s/%s is %s (leaving forced drain)",
4585 s->flags & SRV_F_BACKUP ? "Backup " : "",
4586 s->proxy->id, s->id,
4587 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
4588 }
4589 else {
4590 chunk_printf(tmptrash,
4591 "%sServer %s/%s is %s (leaving drain)",
4592 s->flags & SRV_F_BACKUP ? "Backup " : "",
4593 s->proxy->id, s->id,
4594 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
4595 if (s->track) /* normally it's mandatory here */
4596 chunk_appendf(tmptrash, " via %s/%s",
4597 s->track->proxy->id, s->track->id);
4598 }
4599
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004600 ha_warning("%s.\n", tmptrash->area);
4601 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4602 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004603 free_trash_chunk(tmptrash);
4604 tmptrash = NULL;
4605 }
4606
4607 /* now propagate the status change to any LB algorithms */
4608 if (px->lbprm.update_server_eweight)
4609 px->lbprm.update_server_eweight(s);
4610 else if (srv_willbe_usable(s)) {
4611 if (px->lbprm.set_server_status_up)
4612 px->lbprm.set_server_status_up(s);
4613 }
4614 else {
4615 if (px->lbprm.set_server_status_down)
4616 px->lbprm.set_server_status_down(s);
4617 }
4618 }
4619 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
4620 /* remaining in drain mode after removing one of its flags */
4621
4622 tmptrash = alloc_trash_chunk();
4623 if (tmptrash) {
4624 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
4625 chunk_printf(tmptrash,
4626 "%sServer %s/%s is leaving forced drain but remains in drain mode",
4627 s->flags & SRV_F_BACKUP ? "Backup " : "",
4628 s->proxy->id, s->id);
4629
4630 if (s->track) /* normally it's mandatory here */
4631 chunk_appendf(tmptrash, " via %s/%s",
4632 s->track->proxy->id, s->track->id);
4633 }
4634 else {
4635 chunk_printf(tmptrash,
4636 "%sServer %s/%s remains in forced drain mode",
4637 s->flags & SRV_F_BACKUP ? "Backup " : "",
4638 s->proxy->id, s->id);
4639 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004640 ha_warning("%s.\n", tmptrash->area);
4641 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4642 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004643 free_trash_chunk(tmptrash);
4644 tmptrash = NULL;
4645 }
4646
4647 /* commit new admin status */
4648
4649 s->cur_admin = s->next_admin;
4650 }
4651 }
4652
4653 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02004654 *s->adm_st_chg_cause = 0;
4655}
Emeric Brun64cc49c2017-10-03 14:46:45 +02004656
Willy Tarreau144f84a2021-03-02 16:09:26 +01004657struct task *srv_cleanup_toremove_conns(struct task *task, void *context, unsigned int state)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004658{
4659 struct connection *conn;
4660
Willy Tarreau4d82bf52020-06-28 00:19:17 +02004661 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004662 struct connection *, toremove_list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02004663 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004664 }
4665
4666 return task;
4667}
4668
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004669/* Move toremove_nb connections from idle_tree to toremove_list, -1 means
Olivier Houchardff1d0922020-06-29 20:15:59 +02004670 * moving them all.
4671 * Returns the number of connections moved.
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004672 *
4673 * Must be called with idle_conns_lock held.
Olivier Houchardff1d0922020-06-29 20:15:59 +02004674 */
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004675static 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 +02004676{
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004677 struct eb_node *node, *next;
Amaury Denoyelle8990b012021-02-19 15:29:16 +01004678 struct conn_hash_node *hash_node;
Olivier Houchardff1d0922020-06-29 20:15:59 +02004679 int i = 0;
4680
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004681 node = eb_first(idle_tree);
4682 while (node) {
4683 next = eb_next(node);
Olivier Houchardff1d0922020-06-29 20:15:59 +02004684 if (toremove_nb != -1 && i >= toremove_nb)
4685 break;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004686
Amaury Denoyelle8990b012021-02-19 15:29:16 +01004687 hash_node = ebmb_entry(node, struct conn_hash_node, node);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004688 eb_delete(node);
Amaury Denoyelle8990b012021-02-19 15:29:16 +01004689 MT_LIST_ADDQ(toremove_list, &hash_node->conn->toremove_list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02004690 i++;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004691
4692 node = next;
Olivier Houchardff1d0922020-06-29 20:15:59 +02004693 }
4694 return i;
4695}
William Dauchy6318d332020-05-02 21:52:36 +02004696/* cleanup connections for a given server
4697 * might be useful when going on forced maintenance or live changing ip/port
4698 */
William Dauchy707ad322020-05-04 13:52:40 +02004699static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02004700{
William Dauchy6318d332020-05-02 21:52:36 +02004701 int did_remove;
4702 int i;
William Dauchy6318d332020-05-02 21:52:36 +02004703
Amaury Denoyelle10d5c312021-01-06 14:28:51 +01004704 /* nothing to do if pool-max-conn is null */
4705 if (!srv->max_idle_conns)
4706 return;
4707
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004708 /* check all threads starting with ours */
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004709 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02004710 did_remove = 0;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004711 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01004712 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 +02004713 did_remove = 1;
Willy Tarreau430bf4a2021-03-04 09:45:32 +01004714 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 +02004715 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004716 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
William Dauchy6318d332020-05-02 21:52:36 +02004717 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02004718 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004719
4720 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
4721 break;
William Dauchy6318d332020-05-02 21:52:36 +02004722 }
William Dauchy6318d332020-05-02 21:52:36 +02004723}
4724
Willy Tarreau144f84a2021-03-02 16:09:26 +01004725struct task *srv_cleanup_idle_conns(struct task *task, void *context, unsigned int state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004726{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004727 struct server *srv;
4728 struct eb32_node *eb;
4729 int i;
4730 unsigned int next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01004731
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004732 next_wakeup = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004733 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
4734 while (1) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004735 int exceed_conns;
4736 int to_kill;
4737 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01004738
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004739 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
4740 if (!eb) {
4741 /* we might have reached the end of the tree, typically because
4742 * <now_ms> is in the first half and we're first scanning the last
4743 * half. Let's loop back to the beginning of the tree now.
4744 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004745
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004746 eb = eb32_first(&idle_conn_srv);
4747 if (likely(!eb))
4748 break;
4749 }
4750 if (tick_is_lt(now_ms, eb->key)) {
4751 /* timer not expired yet, revisit it later */
4752 next_wakeup = eb->key;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004753 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004754 }
4755 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004756
4757 /* Calculate how many idle connections we want to kill :
4758 * we want to remove half the difference between the total
4759 * of established connections (used or idle) and the max
4760 * number of used connections.
4761 */
4762 curr_idle = srv->curr_idle_conns;
4763 if (curr_idle == 0)
4764 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02004765 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004766 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02004767
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004768 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns) / 2;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02004769 if (srv->est_need_conns < srv->max_used_conns)
4770 srv->est_need_conns = srv->max_used_conns;
4771
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004772 srv->max_used_conns = srv->curr_used_conns;
4773
Willy Tarreau18ed7892020-07-02 19:05:30 +02004774 if (exceed_conns <= 0)
4775 goto remove;
4776
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004777 /* check all threads starting with ours */
4778 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004779 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004780 int j;
4781 int did_remove = 0;
4782
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004783 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
4784 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02004785
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004786 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01004787 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 +02004788 if (j > 0)
4789 did_remove = 1;
4790 if (max_conn - j > 0 &&
Willy Tarreau430bf4a2021-03-04 09:45:32 +01004791 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 +01004792 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004793 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Olivier Houchardff1d0922020-06-29 20:15:59 +02004794
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004795 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02004796 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004797
4798 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
4799 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004800 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004801remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004802 eb32_delete(&srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004803
4804 if (srv->curr_idle_conns) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004805 /* There are still more idle connections, add the
4806 * server back in the tree.
4807 */
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004808 srv->idle_node.key = tick_add(srv->pool_purge_delay, now_ms);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004809 eb32_insert(&idle_conn_srv, &srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004810 next_wakeup = tick_first(next_wakeup, srv->idle_node.key);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004811 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004812 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004813 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
4814
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004815 task->expire = next_wakeup;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004816 return task;
4817}
Olivier Houchard88698d92019-04-16 19:07:22 +02004818
Willy Tarreau76cc6992020-07-01 18:49:24 +02004819/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
4820static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01004821 const struct proxy *defpx, const char *file, int line,
Willy Tarreau76cc6992020-07-01 18:49:24 +02004822 char **err)
4823{
4824 if (too_many_args(1, args, err, NULL))
4825 return -1;
4826
4827 if (strcmp(args[1], "on") == 0)
4828 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
4829 else if (strcmp(args[1], "off") == 0)
4830 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
4831 else {
4832 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
4833 return -1;
4834 }
4835 return 0;
4836}
4837
Olivier Houchard88698d92019-04-16 19:07:22 +02004838/* config parser for global "tune.pool-{low,high}-fd-ratio" */
4839static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01004840 const struct proxy *defpx, const char *file, int line,
Olivier Houchard88698d92019-04-16 19:07:22 +02004841 char **err)
4842{
4843 int arg = -1;
4844
4845 if (too_many_args(1, args, err, NULL))
4846 return -1;
4847
4848 if (*(args[1]) != 0)
4849 arg = atoi(args[1]);
4850
4851 if (arg < 0 || arg > 100) {
4852 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
4853 return -1;
4854 }
4855
4856 if (args[0][10] == 'h')
4857 global.tune.pool_high_ratio = arg;
4858 else
4859 global.tune.pool_low_ratio = arg;
4860 return 0;
4861}
4862
4863/* config keyword parsers */
4864static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02004865 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02004866 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
4867 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
4868 { 0, NULL, NULL }
4869}};
4870
4871INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
4872
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004873/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004874 * Local variables:
4875 * c-indent-level: 8
4876 * c-basic-offset: 8
4877 * End:
4878 */