blob: 3a3ccc672b144ac4b4cfd2d8eeec1a0d7c12aca1 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Server management functions.
3 *
Willy Tarreau21faa912012-10-10 08:27:36 +02004 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01005 * Copyright 2007-2008 Krzysztof Piotr Oledzki <ole@ans.pl>
Willy Tarreaubaaee002006-06-26 02:48:02 +02006 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
Willy Tarreau0a4b0ab2020-06-11 11:22:44 +020014#include <sys/types.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020015#include <netinet/tcp.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020016#include <ctype.h>
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020017#include <errno.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020018
Willy Tarreaub2551052020-06-09 09:07:15 +020019#include <import/ebsttree.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020020#include <import/xxhash.h>
21
Willy Tarreaub2551052020-06-09 09:07:15 +020022#include <haproxy/api.h>
Willy Tarreau3f0f82e2020-06-04 19:42:41 +020023#include <haproxy/applet-t.h>
Willy Tarreau49801602020-06-04 22:50:02 +020024#include <haproxy/backend.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020025#include <haproxy/cfgparse.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020026#include <haproxy/check.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020027#include <haproxy/cli.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020028#include <haproxy/connection.h>
Willy Tarreau3afc4c42020-06-03 18:23:19 +020029#include <haproxy/dict-t.h>
Willy Tarreaueb92deb2020-06-04 10:53:16 +020030#include <haproxy/dns.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020031#include <haproxy/errors.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020032#include <haproxy/global.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020033#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020034#include <haproxy/mailers.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020035#include <haproxy/namespace.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020036#include <haproxy/port_range.h>
37#include <haproxy/protocol.h>
Willy Tarreaua55c4542020-06-04 22:59:39 +020038#include <haproxy/queue.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020039#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020040#include <haproxy/server.h>
William Dauchyf6370442020-11-14 19:25:33 +010041#include <haproxy/ssl_sock.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020042#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020043#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020044#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020045#include <haproxy/task.h>
Willy Tarreau51cd5952020-06-05 12:25:38 +020046#include <haproxy/tcpcheck.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020047#include <haproxy/time.h>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020048
Baptiste Assmannda29fe22019-06-13 13:24:29 +020049
Willy Tarreau3ff577e2018-08-02 11:48:52 +020050static void srv_update_status(struct server *s);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020051static void srv_update_state(struct server *srv, int version, char **params);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010052static int srv_apply_lastaddr(struct server *srv, int *err_code);
Olivier Houchardd16bfe62017-10-31 15:21:19 +010053static int srv_set_fqdn(struct server *srv, const char *fqdn, int dns_locked);
Baptiste Assmannda29fe22019-06-13 13:24:29 +020054static void srv_state_parse_line(char *buf, const int version, char **params, char **srv_params);
55static int srv_state_get_version(FILE *f);
William Dauchy6318d332020-05-02 21:52:36 +020056static void srv_cleanup_connections(struct server *srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +020057
Willy Tarreau21faa912012-10-10 08:27:36 +020058/* List head of all known server keywords */
59static struct srv_kw_list srv_keywords = {
60 .list = LIST_HEAD_INIT(srv_keywords.list)
61};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020062
Willy Tarreauaf613e82020-06-05 08:40:51 +020063__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010064struct eb_root idle_conn_srv = EB_ROOT;
65struct task *idle_conn_task = NULL;
Olivier Houchard9ea5d362019-02-14 18:29:09 +010066
Frédéric Lécaille7da71292019-05-20 09:47:07 +020067/* The server names dictionary */
68struct dict server_name_dict = {
69 .name = "server names",
70 .values = EB_ROOT_UNIQUE,
71};
72
Baptiste Assmannda29fe22019-06-13 13:24:29 +020073/* tree where global state_file is loaded */
Willy Tarreaufd1aa012019-12-20 17:23:40 +010074struct eb_root state_file = EB_ROOT_UNIQUE;
Baptiste Assmannda29fe22019-06-13 13:24:29 +020075
Simon Hormana3608442013-11-01 16:46:15 +090076int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020077{
Amaury Denoyellee6ba7912020-10-29 15:59:05 +010078 if ((s->cur_state != SRV_ST_STOPPED) || s->last_change >= now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020079 return s->down_time;
80
81 return now.tv_sec - s->last_change + s->down_time;
82}
Willy Tarreaubaaee002006-06-26 02:48:02 +020083
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050084int srv_lastsession(const struct server *s)
85{
86 if (s->counters.last_sess)
87 return now.tv_sec - s->counters.last_sess;
88
89 return -1;
90}
91
Simon Horman4a741432013-02-23 15:35:38 +090092int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020093{
Simon Horman4a741432013-02-23 15:35:38 +090094 const struct server *s = check->server;
95
Willy Tarreauff5ae352013-12-11 20:36:34 +010096 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090097 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010098
Emeric Brun52a91d32017-08-31 14:41:55 +020099 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +0900100 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100101
Simon Horman4a741432013-02-23 15:35:38 +0900102 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100103}
104
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100105/*
106 * Check that we did not get a hash collision.
Willy Tarreau595e7672020-10-20 17:30:08 +0200107 * Unlikely, but it can happen. The server's proxy must be at least
108 * read-locked.
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100109 */
110static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +0100111{
112 struct proxy *p = s->proxy;
113 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100114
115 for (tmpserv = p->srv; tmpserv != NULL;
116 tmpserv = tmpserv->next) {
117 if (tmpserv == s)
118 continue;
119 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
120 continue;
121 if (tmpserv->cookie &&
122 strcmp(tmpserv->cookie, s->cookie) == 0) {
123 ha_warning("We generated two equal cookies for two different servers.\n"
124 "Please change the secret key for '%s'.\n",
125 s->proxy->id);
126 }
127 }
128
129}
130
Willy Tarreau46b7f532018-08-21 11:54:26 +0200131/*
Willy Tarreau595e7672020-10-20 17:30:08 +0200132 * Must be called with the server lock held, and will read-lock the proxy.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200133 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100134void srv_set_dyncookie(struct server *s)
135{
136 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100137 char *tmpbuf;
138 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100139 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100140 size_t buffer_len;
141 int addr_len;
142 int port;
143
Willy Tarreau595e7672020-10-20 17:30:08 +0200144 HA_RWLOCK_RDLOCK(PROXY_LOCK, &p->lock);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200145
Olivier Houchard4e694042017-03-14 20:01:29 +0100146 if ((s->flags & SRV_F_COOKIESET) ||
147 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
148 s->proxy->dyncookie_key == NULL)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200149 goto out;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100150 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100151
152 if (s->addr.ss_family != AF_INET &&
153 s->addr.ss_family != AF_INET6)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200154 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100155 /*
156 * Buffer to calculate the cookie value.
157 * The buffer contains the secret key + the server IP address
158 * + the TCP port.
159 */
160 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
161 /*
162 * The TCP port should use only 2 bytes, but is stored in
163 * an unsigned int in struct server, so let's use 4, to be
164 * on the safe side.
165 */
166 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200167 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100168 memcpy(tmpbuf, p->dyncookie_key, key_len);
169 memcpy(&(tmpbuf[key_len]),
170 s->addr.ss_family == AF_INET ?
171 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
172 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
173 addr_len);
174 /*
175 * Make sure it's the same across all the load balancers,
176 * no matter their endianness.
177 */
178 port = htonl(s->svc_port);
179 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
180 hash_value = XXH64(tmpbuf, buffer_len, 0);
181 memprintf(&s->cookie, "%016llx", hash_value);
182 if (!s->cookie)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200183 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100184 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100185
186 /* Don't bother checking if the dyncookie is duplicated if
187 * the server is marked as "disabled", maybe it doesn't have
188 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100189 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100190 if (!(s->next_admin & SRV_ADMF_FMAINT))
191 srv_check_for_dup_dyncookie(s);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200192 out:
Willy Tarreau595e7672020-10-20 17:30:08 +0200193 HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &p->lock);
Olivier Houchard4e694042017-03-14 20:01:29 +0100194}
195
Willy Tarreau21faa912012-10-10 08:27:36 +0200196/*
197 * Registers the server keyword list <kwl> as a list of valid keywords for next
198 * parsing sessions.
199 */
200void srv_register_keywords(struct srv_kw_list *kwl)
201{
202 LIST_ADDQ(&srv_keywords.list, &kwl->list);
203}
204
205/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
206 * keyword is found with a NULL ->parse() function, then an attempt is made to
207 * find one with a valid ->parse() function. This way it is possible to declare
208 * platform-dependant, known keywords as NULL, then only declare them as valid
209 * if some options are met. Note that if the requested keyword contains an
210 * opening parenthesis, everything from this point is ignored.
211 */
212struct srv_kw *srv_find_kw(const char *kw)
213{
214 int index;
215 const char *kwend;
216 struct srv_kw_list *kwl;
217 struct srv_kw *ret = NULL;
218
219 kwend = strchr(kw, '(');
220 if (!kwend)
221 kwend = kw + strlen(kw);
222
223 list_for_each_entry(kwl, &srv_keywords.list, list) {
224 for (index = 0; kwl->kw[index].kw != NULL; index++) {
225 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
226 kwl->kw[index].kw[kwend-kw] == 0) {
227 if (kwl->kw[index].parse)
228 return &kwl->kw[index]; /* found it !*/
229 else
230 ret = &kwl->kw[index]; /* may be OK */
231 }
232 }
233 }
234 return ret;
235}
236
237/* Dumps all registered "server" keywords to the <out> string pointer. The
238 * unsupported keywords are only dumped if their supported form was not
239 * found.
240 */
241void srv_dump_kws(char **out)
242{
243 struct srv_kw_list *kwl;
244 int index;
245
Christopher Faulet784063e2020-05-18 12:14:18 +0200246 if (!out)
247 return;
248
Willy Tarreau21faa912012-10-10 08:27:36 +0200249 *out = NULL;
250 list_for_each_entry(kwl, &srv_keywords.list, list) {
251 for (index = 0; kwl->kw[index].kw != NULL; index++) {
252 if (kwl->kw[index].parse ||
253 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
254 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
255 kwl->scope,
256 kwl->kw[index].kw,
257 kwl->kw[index].skip ? " <arg>" : "",
258 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
259 kwl->kw[index].parse ? "" : " (not supported)");
260 }
261 }
262 }
263}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100264
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100265/* Parse the "backup" server keyword */
266static int srv_parse_backup(char **args, int *cur_arg,
267 struct proxy *curproxy, struct server *newsrv, char **err)
268{
269 newsrv->flags |= SRV_F_BACKUP;
270 return 0;
271}
272
Alexander Liu2a54bb72019-05-22 19:44:48 +0800273
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100274/* Parse the "cookie" server keyword */
275static int srv_parse_cookie(char **args, int *cur_arg,
276 struct proxy *curproxy, struct server *newsrv, char **err)
277{
278 char *arg;
279
280 arg = args[*cur_arg + 1];
281 if (!*arg) {
282 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
283 return ERR_ALERT | ERR_FATAL;
284 }
285
286 free(newsrv->cookie);
287 newsrv->cookie = strdup(arg);
288 newsrv->cklen = strlen(arg);
289 newsrv->flags |= SRV_F_COOKIESET;
290 return 0;
291}
292
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100293/* Parse the "disabled" server keyword */
294static int srv_parse_disabled(char **args, int *cur_arg,
295 struct proxy *curproxy, struct server *newsrv, char **err)
296{
Emeric Brun52a91d32017-08-31 14:41:55 +0200297 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
298 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100299 newsrv->check.state |= CHK_ST_PAUSED;
300 newsrv->check.health = 0;
301 return 0;
302}
303
304/* Parse the "enabled" server keyword */
305static int srv_parse_enabled(char **args, int *cur_arg,
306 struct proxy *curproxy, struct server *newsrv, char **err)
307{
Emeric Brun52a91d32017-08-31 14:41:55 +0200308 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
309 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100310 newsrv->check.state &= ~CHK_ST_PAUSED;
311 newsrv->check.health = newsrv->check.rise;
312 return 0;
313}
314
Willy Tarreau9c538e02019-01-23 10:21:49 +0100315static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
316{
317 char *arg;
318
319 arg = args[*cur_arg + 1];
320 if (!*arg) {
321 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
322 return ERR_ALERT | ERR_FATAL;
323 }
324 newsrv->max_reuse = atoi(arg);
325
326 return 0;
327}
328
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100329static 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 +0100330{
331 const char *res;
332 char *arg;
333 unsigned int time;
334
335 arg = args[*cur_arg + 1];
336 if (!*arg) {
337 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
338 return ERR_ALERT | ERR_FATAL;
339 }
340 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200341 if (res == PARSE_TIME_OVER) {
342 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
343 args[*cur_arg+1], args[*cur_arg]);
344 return ERR_ALERT | ERR_FATAL;
345 }
346 else if (res == PARSE_TIME_UNDER) {
347 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
348 args[*cur_arg+1], args[*cur_arg]);
349 return ERR_ALERT | ERR_FATAL;
350 }
351 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100352 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
353 *res, args[*cur_arg]);
354 return ERR_ALERT | ERR_FATAL;
355 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100356 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100357
358 return 0;
359}
360
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200361static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
362{
363 char *arg;
364
365 arg = args[*cur_arg + 1];
366 if (!*arg) {
367 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
368 return ERR_ALERT | ERR_FATAL;
369 }
370
371 newsrv->low_idle_conns = atoi(arg);
372 return 0;
373}
374
Olivier Houchard006e3102018-12-10 18:30:32 +0100375static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
376{
377 char *arg;
378
379 arg = args[*cur_arg + 1];
380 if (!*arg) {
381 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
382 return ERR_ALERT | ERR_FATAL;
383 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100384
Olivier Houchard006e3102018-12-10 18:30:32 +0100385 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100386 if ((int)newsrv->max_idle_conns < -1) {
387 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
388 return ERR_ALERT | ERR_FATAL;
389 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100390
391 return 0;
392}
393
Willy Tarreaudff55432012-10-10 17:51:05 +0200394/* parse the "id" server keyword */
395static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
396{
397 struct eb32_node *node;
398
399 if (!*args[*cur_arg + 1]) {
400 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
401 return ERR_ALERT | ERR_FATAL;
402 }
403
404 newsrv->puid = atol(args[*cur_arg + 1]);
405 newsrv->conf.id.key = newsrv->puid;
406
407 if (newsrv->puid <= 0) {
408 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
409 return ERR_ALERT | ERR_FATAL;
410 }
411
412 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
413 if (node) {
414 struct server *target = container_of(node, struct server, conf.id);
415 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
416 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
417 target->id);
418 return ERR_ALERT | ERR_FATAL;
419 }
420
421 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200422 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200423 return 0;
424}
425
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100426/* Parse the "namespace" server keyword */
427static int srv_parse_namespace(char **args, int *cur_arg,
428 struct proxy *curproxy, struct server *newsrv, char **err)
429{
Willy Tarreaue5733232019-05-22 19:24:06 +0200430#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100431 char *arg;
432
433 arg = args[*cur_arg + 1];
434 if (!*arg) {
435 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
436 return ERR_ALERT | ERR_FATAL;
437 }
438
439 if (!strcmp(arg, "*")) {
440 /* Use the namespace associated with the connection (if present). */
441 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
442 return 0;
443 }
444
445 /*
446 * As this parser may be called several times for the same 'default-server'
447 * object, or for a new 'server' instance deriving from a 'default-server'
448 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
449 */
450 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
451
452 newsrv->netns = netns_store_lookup(arg, strlen(arg));
453 if (!newsrv->netns)
454 newsrv->netns = netns_store_insert(arg);
455
456 if (!newsrv->netns) {
457 memprintf(err, "Cannot open namespace '%s'", arg);
458 return ERR_ALERT | ERR_FATAL;
459 }
460
461 return 0;
462#else
463 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
464 return ERR_ALERT | ERR_FATAL;
465#endif
466}
467
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100468/* Parse the "no-backup" server keyword */
469static int srv_parse_no_backup(char **args, int *cur_arg,
470 struct proxy *curproxy, struct server *newsrv, char **err)
471{
472 newsrv->flags &= ~SRV_F_BACKUP;
473 return 0;
474}
475
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100476
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100477/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200478static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100479{
480 srv->pp_opts &= ~flags;
481 return 0;
482}
483
484/* Parse the "no-send-proxy" server keyword */
485static int srv_parse_no_send_proxy(char **args, int *cur_arg,
486 struct proxy *curproxy, struct server *newsrv, char **err)
487{
488 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
489}
490
491/* Parse the "no-send-proxy-v2" server keyword */
492static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
493 struct proxy *curproxy, struct server *newsrv, char **err)
494{
495 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
496}
497
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200498/* Parse the "no-tfo" server keyword */
499static int srv_parse_no_tfo(char **args, int *cur_arg,
500 struct proxy *curproxy, struct server *newsrv, char **err)
501{
502 newsrv->flags &= ~SRV_F_FASTOPEN;
503 return 0;
504}
505
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100506/* Parse the "non-stick" server keyword */
507static int srv_parse_non_stick(char **args, int *cur_arg,
508 struct proxy *curproxy, struct server *newsrv, char **err)
509{
510 newsrv->flags |= SRV_F_NON_STICK;
511 return 0;
512}
513
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100514/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200515static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100516{
517 srv->pp_opts |= flags;
518 return 0;
519}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200520/* parse the "proto" server keyword */
521static int srv_parse_proto(char **args, int *cur_arg,
522 struct proxy *px, struct server *newsrv, char **err)
523{
524 struct ist proto;
525
526 if (!*args[*cur_arg + 1]) {
527 memprintf(err, "'%s' : missing value", args[*cur_arg]);
528 return ERR_ALERT | ERR_FATAL;
529 }
530 proto = ist2(args[*cur_arg + 1], strlen(args[*cur_arg + 1]));
531 newsrv->mux_proto = get_mux_proto(proto);
532 if (!newsrv->mux_proto) {
533 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
534 return ERR_ALERT | ERR_FATAL;
535 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200536 return 0;
537}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100538
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100539/* parse the "proxy-v2-options" */
540static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
541 struct proxy *px, struct server *newsrv, char **err)
542{
543 char *p, *n;
544 for (p = args[*cur_arg+1]; p; p = n) {
545 n = strchr(p, ',');
546 if (n)
547 *n++ = '\0';
548 if (!strcmp(p, "ssl")) {
549 newsrv->pp_opts |= SRV_PP_V2_SSL;
550 } else if (!strcmp(p, "cert-cn")) {
551 newsrv->pp_opts |= SRV_PP_V2_SSL;
552 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100553 } else if (!strcmp(p, "cert-key")) {
554 newsrv->pp_opts |= SRV_PP_V2_SSL;
555 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
556 } else if (!strcmp(p, "cert-sig")) {
557 newsrv->pp_opts |= SRV_PP_V2_SSL;
558 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
559 } else if (!strcmp(p, "ssl-cipher")) {
560 newsrv->pp_opts |= SRV_PP_V2_SSL;
561 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100562 } else if (!strcmp(p, "authority")) {
563 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100564 } else if (!strcmp(p, "crc32c")) {
565 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100566 } else if (!strcmp(p, "unique-id")) {
567 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100568 } else
569 goto fail;
570 }
571 return 0;
572 fail:
573 if (err)
574 memprintf(err, "'%s' : proxy v2 option not implemented", p);
575 return ERR_ALERT | ERR_FATAL;
576}
577
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100578/* Parse the "observe" server keyword */
579static int srv_parse_observe(char **args, int *cur_arg,
580 struct proxy *curproxy, struct server *newsrv, char **err)
581{
582 char *arg;
583
584 arg = args[*cur_arg + 1];
585 if (!*arg) {
586 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
587 return ERR_ALERT | ERR_FATAL;
588 }
589
590 if (!strcmp(arg, "none")) {
591 newsrv->observe = HANA_OBS_NONE;
592 }
593 else if (!strcmp(arg, "layer4")) {
594 newsrv->observe = HANA_OBS_LAYER4;
595 }
596 else if (!strcmp(arg, "layer7")) {
597 if (curproxy->mode != PR_MODE_HTTP) {
598 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
599 return ERR_ALERT;
600 }
601 newsrv->observe = HANA_OBS_LAYER7;
602 }
603 else {
604 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
605 "but got '%s'\n", args[*cur_arg], arg);
606 return ERR_ALERT | ERR_FATAL;
607 }
608
609 return 0;
610}
611
Frédéric Lécaille16186232017-03-14 16:42:49 +0100612/* Parse the "redir" server keyword */
613static int srv_parse_redir(char **args, int *cur_arg,
614 struct proxy *curproxy, struct server *newsrv, char **err)
615{
616 char *arg;
617
618 arg = args[*cur_arg + 1];
619 if (!*arg) {
620 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
621 return ERR_ALERT | ERR_FATAL;
622 }
623
624 free(newsrv->rdr_pfx);
625 newsrv->rdr_pfx = strdup(arg);
626 newsrv->rdr_len = strlen(arg);
627
628 return 0;
629}
630
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100631/* Parse the "send-proxy" server keyword */
632static int srv_parse_send_proxy(char **args, int *cur_arg,
633 struct proxy *curproxy, struct server *newsrv, char **err)
634{
635 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
636}
637
638/* Parse the "send-proxy-v2" server keyword */
639static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
640 struct proxy *curproxy, struct server *newsrv, char **err)
641{
642 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
643}
644
Frédéric Lécailledba97072017-03-17 15:33:50 +0100645
646/* Parse the "source" server keyword */
647static int srv_parse_source(char **args, int *cur_arg,
648 struct proxy *curproxy, struct server *newsrv, char **err)
649{
650 char *errmsg;
651 int port_low, port_high;
652 struct sockaddr_storage *sk;
Frédéric Lécailledba97072017-03-17 15:33:50 +0100653
654 errmsg = NULL;
655
656 if (!*args[*cur_arg + 1]) {
657 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
658 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
659 goto err;
660 }
661
662 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200663 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
664 &errmsg, NULL, NULL,
665 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 +0100666 if (!sk) {
667 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
668 goto err;
669 }
670
Frédéric Lécailledba97072017-03-17 15:33:50 +0100671 newsrv->conn_src.opts |= CO_SRC_BIND;
672 newsrv->conn_src.source_addr = *sk;
673
674 if (port_low != port_high) {
675 int i;
676
Frédéric Lécailledba97072017-03-17 15:33:50 +0100677 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
678 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
679 newsrv->conn_src.sport_range->ports[i] = port_low + i;
680 }
681
682 *cur_arg += 2;
683 while (*(args[*cur_arg])) {
684 if (!strcmp(args[*cur_arg], "usesrc")) { /* address to use outside */
685#if defined(CONFIG_HAP_TRANSPARENT)
686 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100687 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
688 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100689 goto err;
690 }
691 if (!strcmp(args[*cur_arg + 1], "client")) {
692 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
693 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
694 }
695 else if (!strcmp(args[*cur_arg + 1], "clientip")) {
696 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
697 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
698 }
699 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
700 char *name, *end;
701
702 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +0100703 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100704 name++;
705
706 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +0100707 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +0100708 end++;
709
710 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
711 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
712 free(newsrv->conn_src.bind_hdr_name);
713 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
714 newsrv->conn_src.bind_hdr_len = end - name;
715 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
716 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
717 newsrv->conn_src.bind_hdr_occ = -1;
718
719 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +0100720 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100721 end++;
722 if (*end == ',') {
723 end++;
724 name = end;
725 if (*end == '-')
726 end++;
Willy Tarreau90807112020-02-25 08:16:33 +0100727 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100728 end++;
729 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
730 }
731
732 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100733 ha_alert("usesrc hdr_ip(name,num) does not support negative"
734 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100735 goto err;
736 }
737 }
738 else {
739 struct sockaddr_storage *sk;
740 int port1, port2;
741
742 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200743 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, NULL, NULL,
744 &errmsg, NULL, NULL,
745 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100746 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100747 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100748 goto err;
749 }
750
Frédéric Lécailledba97072017-03-17 15:33:50 +0100751 newsrv->conn_src.tproxy_addr = *sk;
752 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
753 }
754 global.last_checks |= LSTCHK_NETADM;
755 *cur_arg += 2;
756 continue;
757#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100758 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 +0100759 goto err;
760#endif /* defined(CONFIG_HAP_TRANSPARENT) */
761 } /* "usesrc" */
762
763 if (!strcmp(args[*cur_arg], "interface")) { /* specifically bind to this interface */
764#ifdef SO_BINDTODEVICE
765 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100766 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100767 goto err;
768 }
769 free(newsrv->conn_src.iface_name);
770 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
771 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
772 global.last_checks |= LSTCHK_NETADM;
773#else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100774 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100775 goto err;
776#endif
777 *cur_arg += 2;
778 continue;
779 }
780 /* this keyword in not an option of "source" */
781 break;
782 } /* while */
783
784 return 0;
785
786 err:
787 free(errmsg);
788 return ERR_ALERT | ERR_FATAL;
789}
790
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100791/* Parse the "stick" server keyword */
792static int srv_parse_stick(char **args, int *cur_arg,
793 struct proxy *curproxy, struct server *newsrv, char **err)
794{
795 newsrv->flags &= ~SRV_F_NON_STICK;
796 return 0;
797}
798
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100799/* Parse the "track" server keyword */
800static int srv_parse_track(char **args, int *cur_arg,
801 struct proxy *curproxy, struct server *newsrv, char **err)
802{
803 char *arg;
804
805 arg = args[*cur_arg + 1];
806 if (!*arg) {
807 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
808 return ERR_ALERT | ERR_FATAL;
809 }
810
811 free(newsrv->trackit);
812 newsrv->trackit = strdup(arg);
813
814 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800815}
816
817/* Parse the "socks4" server keyword */
818static int srv_parse_socks4(char **args, int *cur_arg,
819 struct proxy *curproxy, struct server *newsrv, char **err)
820{
821 char *errmsg;
822 int port_low, port_high;
823 struct sockaddr_storage *sk;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800824
825 errmsg = NULL;
826
827 if (!*args[*cur_arg + 1]) {
828 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
829 goto err;
830 }
831
832 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200833 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
834 &errmsg, NULL, NULL,
835 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_CONNECT);
Alexander Liu2a54bb72019-05-22 19:44:48 +0800836 if (!sk) {
837 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
838 goto err;
839 }
840
Alexander Liu2a54bb72019-05-22 19:44:48 +0800841 newsrv->flags |= SRV_F_SOCKS4_PROXY;
842 newsrv->socks4_addr = *sk;
843
Alexander Liu2a54bb72019-05-22 19:44:48 +0800844 return 0;
845
846 err:
847 free(errmsg);
848 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100849}
850
Frédéric Lécailledba97072017-03-17 15:33:50 +0100851
Willy Tarreau034c88c2017-01-23 23:36:45 +0100852/* parse the "tfo" server keyword */
853static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
854{
855 newsrv->flags |= SRV_F_FASTOPEN;
856 return 0;
857}
858
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200859/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200860 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200861 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200862 *
863 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200864 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200865void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200866{
Willy Tarreau87b09662015-04-03 00:22:06 +0200867 struct stream *stream, *stream_bck;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200868
Willy Tarreau87b09662015-04-03 00:22:06 +0200869 list_for_each_entry_safe(stream, stream_bck, &srv->actconns, by_srv)
870 if (stream->srv_conn == srv)
871 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200872}
873
874/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200875 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200876 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200877 *
878 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200879 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200880void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200881{
882 struct server *srv;
883
884 for (srv = px->srv; srv != NULL; srv = srv->next)
885 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200886 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200887}
888
Willy Tarreaubda92272014-05-20 21:55:30 +0200889/* Appends some information to a message string related to a server going UP or
890 * DOWN. If both <forced> and <reason> are null and the server tracks another
891 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +0200892 * If <check> is non-null, an entire string describing the check result will be
893 * appended after a comma and a space (eg: to report some information from the
894 * check that changed the state). In the other case, the string will be built
895 * using the check results stored into the struct server if present.
896 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +0200897 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200898 *
899 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200900 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200901void srv_append_status(struct buffer *msg, struct server *s,
902 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200903{
Emeric Brun5a133512017-10-19 14:42:30 +0200904 short status = s->op_st_chg.status;
905 short code = s->op_st_chg.code;
906 long duration = s->op_st_chg.duration;
907 char *desc = s->op_st_chg.reason;
908
909 if (check) {
910 status = check->status;
911 code = check->code;
912 duration = check->duration;
913 desc = check->desc;
914 }
915
916 if (status != -1) {
917 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
918
919 if (status >= HCHK_STATUS_L57DATA)
920 chunk_appendf(msg, ", code: %d", code);
921
922 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200923 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +0200924
925 chunk_appendf(msg, ", info: \"");
926
927 chunk_initlen(&src, desc, 0, strlen(desc));
928 chunk_asciiencode(msg, &src, '"');
929
930 chunk_appendf(msg, "\"");
931 }
932
933 if (duration >= 0)
934 chunk_appendf(msg, ", check duration: %ldms", duration);
935 }
936 else if (desc && *desc) {
937 chunk_appendf(msg, ", %s", desc);
938 }
939 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +0200940 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +0200941 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200942
943 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200944 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200945 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
946 " %d sessions active, %d requeued, %d remaining in queue",
947 s->proxy->srv_act, s->proxy->srv_bck,
948 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
949 s->cur_sess, xferred, s->nbpend);
950 else
951 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
952 " %d sessions requeued, %d total in queue",
953 s->proxy->srv_act, s->proxy->srv_bck,
954 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
955 xferred, s->nbpend);
956 }
957}
958
Emeric Brun5a133512017-10-19 14:42:30 +0200959/* Marks server <s> down, regardless of its checks' statuses. The server is
960 * registered in a list to postpone the counting of the remaining servers on
961 * the proxy and transfers queued streams whenever possible to other servers at
962 * a sync point. Maintenance servers are ignored. It stores the <reason> if
963 * non-null as the reason for going down or the available data from the check
964 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200965 *
966 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200967 */
Emeric Brun5a133512017-10-19 14:42:30 +0200968void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200969{
970 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200971
Emeric Brun64cc49c2017-10-03 14:46:45 +0200972 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200973 return;
974
Emeric Brun52a91d32017-08-31 14:41:55 +0200975 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +0200976 *s->op_st_chg.reason = 0;
977 s->op_st_chg.status = -1;
978 if (reason) {
979 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
980 }
981 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +0100982 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +0200983 s->op_st_chg.code = check->code;
984 s->op_st_chg.status = check->status;
985 s->op_st_chg.duration = check->duration;
986 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200987
Willy Tarreaueeba36b2018-08-21 08:22:26 +0200988 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +0200989 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +0200990
Emeric Brun9f0b4582017-10-23 14:39:51 +0200991 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100992 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +0200993 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100994 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200995 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200996}
997
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200998/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +0200999 * in maintenance. The server is registered in a list to postpone the counting
1000 * of the remaining servers on the proxy and tries to grab requests from the
1001 * proxy at a sync point. Maintenance servers are ignored. It stores the
1002 * <reason> if non-null as the reason for going down or the available data
1003 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001004 *
1005 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001006 */
Emeric Brun5a133512017-10-19 14:42:30 +02001007void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001008{
1009 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001010
Emeric Brun64cc49c2017-10-03 14:46:45 +02001011 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001012 return;
1013
Emeric Brun52a91d32017-08-31 14:41:55 +02001014 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001015 return;
1016
Emeric Brun52a91d32017-08-31 14:41:55 +02001017 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001018 *s->op_st_chg.reason = 0;
1019 s->op_st_chg.status = -1;
1020 if (reason) {
1021 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1022 }
1023 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001024 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001025 s->op_st_chg.code = check->code;
1026 s->op_st_chg.status = check->status;
1027 s->op_st_chg.duration = check->duration;
1028 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001029
Emeric Brun64cc49c2017-10-03 14:46:45 +02001030 if (s->slowstart <= 0)
1031 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001032
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001033 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001034 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001035
Emeric Brun9f0b4582017-10-23 14:39:51 +02001036 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001037 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001038 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001039 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001040 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001041}
1042
Willy Tarreau8eb77842014-05-21 13:54:57 +02001043/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001044 * isn't in maintenance. The server is registered in a list to postpone the
1045 * counting of the remaining servers on the proxy and tries to grab requests
1046 * from the proxy. Maintenance servers are ignored. It stores the
1047 * <reason> if non-null as the reason for going down or the available data
1048 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001049 * up. Note that it makes use of the trash to build the log strings, so <reason>
1050 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001051 *
1052 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001053 */
Emeric Brun5a133512017-10-19 14:42:30 +02001054void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001055{
1056 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001057
Emeric Brun64cc49c2017-10-03 14:46:45 +02001058 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001059 return;
1060
Emeric Brun52a91d32017-08-31 14:41:55 +02001061 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001062 return;
1063
Emeric Brun52a91d32017-08-31 14:41:55 +02001064 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001065 *s->op_st_chg.reason = 0;
1066 s->op_st_chg.status = -1;
1067 if (reason) {
1068 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1069 }
1070 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001071 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001072 s->op_st_chg.code = check->code;
1073 s->op_st_chg.status = check->status;
1074 s->op_st_chg.duration = check->duration;
1075 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001076
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001077 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001078 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001079
Emeric Brun9f0b4582017-10-23 14:39:51 +02001080 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001081 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001082 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001083 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001084 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001085}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001086
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001087/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1088 * enforce either maint mode or drain mode. It is not allowed to set more than
1089 * one flag at once. The equivalent "inherited" flag is propagated to all
1090 * tracking servers. Maintenance mode disables health checks (but not agent
1091 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001092 * is done. If <cause> is non-null, it will be displayed at the end of the log
1093 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001094 *
1095 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001096 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001097void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001098{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001099 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001100
1101 if (!mode)
1102 return;
1103
1104 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001105 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001106 return;
1107
Emeric Brun52a91d32017-08-31 14:41:55 +02001108 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001109 if (cause)
1110 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1111
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001112 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001113 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001114
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001115 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001116 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1117 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001118 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001119
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001120 /* compute the inherited flag to propagate */
1121 if (mode & SRV_ADMF_MAINT)
1122 mode = SRV_ADMF_IMAINT;
1123 else if (mode & SRV_ADMF_DRAIN)
1124 mode = SRV_ADMF_IDRAIN;
1125
Emeric Brun9f0b4582017-10-23 14:39:51 +02001126 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001127 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001128 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001129 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001130 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001131}
1132
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001133/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1134 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1135 * than one flag at once. The equivalent "inherited" flag is propagated to all
1136 * tracking servers. Leaving maintenance mode re-enables health checks. When
1137 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001138 *
1139 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001140 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001141void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001142{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001143 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001144
1145 if (!mode)
1146 return;
1147
1148 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001149 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001150 return;
1151
Emeric Brun52a91d32017-08-31 14:41:55 +02001152 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001153
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001154 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001155 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001156
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001157 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001158 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1159 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001160 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001161
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001162 if (mode & SRV_ADMF_MAINT)
1163 mode = SRV_ADMF_IMAINT;
1164 else if (mode & SRV_ADMF_DRAIN)
1165 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001166
Emeric Brun9f0b4582017-10-23 14:39:51 +02001167 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001168 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001169 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001170 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001171 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001172}
1173
Willy Tarreau757478e2016-11-03 19:22:19 +01001174/* principle: propagate maint and drain to tracking servers. This is useful
1175 * upon startup so that inherited states are correct.
1176 */
1177static void srv_propagate_admin_state(struct server *srv)
1178{
1179 struct server *srv2;
1180
1181 if (!srv->trackers)
1182 return;
1183
1184 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001185 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001186 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001187 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001188
Emeric Brun52a91d32017-08-31 14:41:55 +02001189 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001190 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001191 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001192 }
1193}
1194
1195/* Compute and propagate the admin states for all servers in proxy <px>.
1196 * Only servers *not* tracking another one are considered, because other
1197 * ones will be handled when the server they track is visited.
1198 */
1199void srv_compute_all_admin_states(struct proxy *px)
1200{
1201 struct server *srv;
1202
1203 for (srv = px->srv; srv; srv = srv->next) {
1204 if (srv->track)
1205 continue;
1206 srv_propagate_admin_state(srv);
1207 }
1208}
1209
Willy Tarreaudff55432012-10-10 17:51:05 +02001210/* Note: must not be declared <const> as its list will be overwritten.
1211 * Please take care of keeping this list alphabetically sorted, doing so helps
1212 * all code contributors.
1213 * Optional keywords are also declared with a NULL ->parse() function so that
1214 * the config parser can report an appropriate error when a known keyword was
1215 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001216 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001217 */
1218static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001219 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +01001220 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001221 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1222 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001223 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Willy Tarreau9c538e02019-01-23 10:21:49 +01001224 { "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 +01001225 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001226 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001227 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1228 { "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 +02001229 { "no-tfo", srv_parse_no_tfo, 0, 1 }, /* Disable use of TCP Fast Open */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001230 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001231 { "observe", srv_parse_observe, 1, 1 }, /* Enables health adjusting based on observing communication with the server */
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001232 { "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 */
Olivier Houchard006e3102018-12-10 18:30:32 +01001233 { "pool-max-conn", srv_parse_pool_max_conn, 1, 1 }, /* Set the max number of orphan idle connections, 0 means unlimited */
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001234 { "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 +02001235 { "proto", srv_parse_proto, 1, 1 }, /* Set the proto to use for all outgoing connections */
Emmanuel Hocdetf643b802018-02-01 15:20:32 +01001236 { "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 +01001237 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001238 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1239 { "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 +02001240 { "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 +01001241 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Olivier Houchard8d82db72019-07-04 13:34:10 +02001242 { "tfo", srv_parse_tfo, 0, 1 }, /* enable TCP Fast Open of server */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001243 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Alexander Liu2a54bb72019-05-22 19:44:48 +08001244 { "socks4", srv_parse_socks4, 1, 1 }, /* Set the socks4 proxy of the server*/
Willy Tarreaudff55432012-10-10 17:51:05 +02001245 { NULL, NULL, 0 },
1246}};
1247
Willy Tarreau0108d902018-11-25 19:14:37 +01001248INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001249
Willy Tarreau004e0452013-11-21 11:22:01 +01001250/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001251 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001252 * state is automatically disabled if the time is elapsed. If <must_update> is
1253 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001254 *
1255 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001256 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001257void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001258{
1259 struct proxy *px = sv->proxy;
1260 unsigned w;
1261
1262 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1263 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001264 if (sv->next_state == SRV_ST_STARTING)
1265 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001266 }
1267
1268 /* We must take care of not pushing the server to full throttle during slow starts.
1269 * It must also start immediately, at least at the minimal step when leaving maintenance.
1270 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001271 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001272 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1273 else
1274 w = px->lbprm.wdiv;
1275
Emeric Brun52a91d32017-08-31 14:41:55 +02001276 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001277
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001278 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001279 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001280 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001281}
1282
Willy Tarreaubaaee002006-06-26 02:48:02 +02001283/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001284 * Parses weight_str and configures sv accordingly.
1285 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001286 *
1287 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001288 */
1289const char *server_parse_weight_change_request(struct server *sv,
1290 const char *weight_str)
1291{
1292 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001293 long int w;
1294 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001295
1296 px = sv->proxy;
1297
1298 /* if the weight is terminated with '%', it is set relative to
1299 * the initial weight, otherwise it is absolute.
1300 */
1301 if (!*weight_str)
1302 return "Require <weight> or <weight%>.\n";
1303
Simon Hormanb796afa2013-02-12 10:45:53 +09001304 w = strtol(weight_str, &end, 10);
1305 if (end == weight_str)
1306 return "Empty weight string empty or preceded by garbage";
1307 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001308 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001309 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001310 /* Avoid integer overflow */
1311 if (w > 25600)
1312 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001313 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001314 if (w > 256)
1315 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001316 }
1317 else if (w < 0 || w > 256)
1318 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001319 else if (end[0] != '\0')
1320 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001321
1322 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1323 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1324
1325 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001326 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001327
1328 return NULL;
1329}
1330
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001331/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001332 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1333 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001334 * Returns:
1335 * - error string on error
1336 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001337 *
1338 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001339 */
1340const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001341 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001342{
1343 unsigned char ip[INET6_ADDRSTRLEN];
1344
1345 if (inet_pton(AF_INET6, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001346 update_server_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001347 return NULL;
1348 }
1349 if (inet_pton(AF_INET, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001350 update_server_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001351 return NULL;
1352 }
1353
1354 return "Could not understand IP address format.\n";
1355}
1356
Willy Tarreau46b7f532018-08-21 11:54:26 +02001357/*
1358 * Must be called with the server lock held.
1359 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001360const char *server_parse_maxconn_change_request(struct server *sv,
1361 const char *maxconn_str)
1362{
1363 long int v;
1364 char *end;
1365
1366 if (!*maxconn_str)
1367 return "Require <maxconn>.\n";
1368
1369 v = strtol(maxconn_str, &end, 10);
1370 if (end == maxconn_str)
1371 return "maxconn string empty or preceded by garbage";
1372 else if (end[0] != '\0')
1373 return "Trailing garbage in maxconn string";
1374
1375 if (sv->maxconn == sv->minconn) { // static maxconn
1376 sv->maxconn = sv->minconn = v;
1377 } else { // dynamic maxconn
1378 sv->maxconn = v;
1379 }
1380
1381 if (may_dequeue_tasks(sv, sv->proxy))
1382 process_srv_queue(sv);
1383
1384 return NULL;
1385}
1386
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001387#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001388static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1389 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001390{
1391 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001392 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001393 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001394 NULL,
1395 };
1396
1397 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001398 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001399
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001400 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001401}
1402
1403static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1404{
1405 struct sample_expr *expr;
1406
1407 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 +01001408 if (!expr) {
1409 memprintf(err, "error detected while parsing sni expression : %s", *err);
1410 return ERR_ALERT | ERR_FATAL;
1411 }
1412
1413 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1414 memprintf(err, "error detected while parsing sni expression : "
1415 " fetch method '%s' extracts information from '%s', "
1416 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001417 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001418 return ERR_ALERT | ERR_FATAL;
1419 }
1420
1421 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1422 release_sample_expr(newsrv->ssl_ctx.sni);
1423 newsrv->ssl_ctx.sni = expr;
1424
1425 return 0;
1426}
1427#endif
1428
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001429static 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 +01001430{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001431 char *msg = "error encountered while processing ";
1432 char *quote = "'";
1433 char *token = args[cur_arg];
1434
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001435 if (err && *err) {
1436 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001437 msg = *err;
1438 quote = "";
1439 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001440 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001441
1442 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
1443 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1444 file, linenum, args[0], args[1],
1445 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001446 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001447 ha_alert("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1448 file, linenum, args[0], args[1],
1449 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001450}
1451
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001452static void srv_conn_src_sport_range_cpy(struct server *srv,
1453 struct server *src)
1454{
1455 int range_sz;
1456
1457 range_sz = src->conn_src.sport_range->size;
1458 if (range_sz > 0) {
1459 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1460 if (srv->conn_src.sport_range != NULL) {
1461 int i;
1462
1463 for (i = 0; i < range_sz; i++) {
1464 srv->conn_src.sport_range->ports[i] =
1465 src->conn_src.sport_range->ports[i];
1466 }
1467 }
1468 }
1469}
1470
1471/*
1472 * Copy <src> server connection source settings to <srv> server everything needed.
1473 */
1474static void srv_conn_src_cpy(struct server *srv, struct server *src)
1475{
1476 srv->conn_src.opts = src->conn_src.opts;
1477 srv->conn_src.source_addr = src->conn_src.source_addr;
1478
1479 /* Source port range copy. */
1480 if (src->conn_src.sport_range != NULL)
1481 srv_conn_src_sport_range_cpy(srv, src);
1482
1483#ifdef CONFIG_HAP_TRANSPARENT
1484 if (src->conn_src.bind_hdr_name != NULL) {
1485 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1486 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1487 }
1488 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1489 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1490#endif
1491 if (src->conn_src.iface_name != NULL)
1492 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1493}
1494
1495/*
1496 * Copy <src> server SSL settings to <srv> server allocating
1497 * everything needed.
1498 */
1499#if defined(USE_OPENSSL)
1500static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1501{
1502 if (src->ssl_ctx.ca_file != NULL)
1503 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1504 if (src->ssl_ctx.crl_file != NULL)
1505 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
1506 if (src->ssl_ctx.client_crt != NULL)
1507 srv->ssl_ctx.client_crt = strdup(src->ssl_ctx.client_crt);
1508
1509 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1510
1511 if (src->ssl_ctx.verify_host != NULL)
1512 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1513 if (src->ssl_ctx.ciphers != NULL)
1514 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02001515 if (src->ssl_ctx.options)
1516 srv->ssl_ctx.options = src->ssl_ctx.options;
1517 if (src->ssl_ctx.methods.flags)
1518 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
1519 if (src->ssl_ctx.methods.min)
1520 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
1521 if (src->ssl_ctx.methods.max)
1522 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
1523
Willy Tarreau5db847a2019-05-09 14:13:35 +02001524#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L && !defined OPENSSL_IS_BORINGSSL)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001525 if (src->ssl_ctx.ciphersuites != NULL)
1526 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
1527#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001528 if (src->sni_expr != NULL)
1529 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001530
1531#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
1532 if (src->ssl_ctx.alpn_str) {
1533 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1534 if (srv->ssl_ctx.alpn_str) {
1535 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1536 src->ssl_ctx.alpn_len);
1537 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1538 }
1539 }
1540#endif
1541#ifdef OPENSSL_NPN_NEGOTIATED
1542 if (src->ssl_ctx.npn_str) {
1543 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1544 if (srv->ssl_ctx.npn_str) {
1545 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1546 src->ssl_ctx.npn_len);
1547 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1548 }
1549 }
1550#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001551}
1552#endif
1553
1554/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001555 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001556 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001557 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001558 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001559static int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001560{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001561 char *hostname_dn;
1562 int hostname_len, hostname_dn_len;
1563
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001564 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001565 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001566
Christopher Faulet67957bd2017-09-27 11:00:59 +02001567 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001568 hostname_dn = trash.area;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001569 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
1570 hostname_dn, trash.size);
1571 if (hostname_dn_len == -1)
1572 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001573
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001574
Christopher Faulet67957bd2017-09-27 11:00:59 +02001575 free(srv->hostname);
1576 free(srv->hostname_dn);
1577 srv->hostname = strdup(hostname);
1578 srv->hostname_dn = strdup(hostname_dn);
1579 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001580 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001581 goto err;
1582
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001583 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001584
1585 err:
Christopher Faulet67957bd2017-09-27 11:00:59 +02001586 free(srv->hostname); srv->hostname = NULL;
1587 free(srv->hostname_dn); srv->hostname_dn = NULL;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001588 return -1;
1589}
1590
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001591/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001592 * Copy <src> server settings to <srv> server allocating
1593 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001594 * This function is not supposed to be called at any time, but only
1595 * during server settings parsing or during server allocations from
1596 * a server template, and just after having calloc()'ed a new server.
1597 * So, <src> may only be a default server (when parsing server settings)
1598 * or a server template (during server allocations from a server template).
1599 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1600 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001601 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001602static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001603{
1604 /* Connection source settings copy */
1605 srv_conn_src_cpy(srv, src);
1606
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001607 if (srv_tmpl) {
1608 srv->addr = src->addr;
1609 srv->svc_port = src->svc_port;
1610 }
1611
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001612 srv->pp_opts = src->pp_opts;
1613 if (src->rdr_pfx != NULL) {
1614 srv->rdr_pfx = strdup(src->rdr_pfx);
1615 srv->rdr_len = src->rdr_len;
1616 }
1617 if (src->cookie != NULL) {
1618 srv->cookie = strdup(src->cookie);
1619 srv->cklen = src->cklen;
1620 }
1621 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01001622 srv->check.addr = src->check.addr;
1623 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001624 srv->check.use_ssl = src->check.use_ssl;
1625 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01001626 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01001627 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05001628 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001629 /* Note: 'flags' field has potentially been already initialized. */
1630 srv->flags |= src->flags;
1631 srv->do_check = src->do_check;
1632 srv->do_agent = src->do_agent;
1633 if (srv->check.port)
1634 srv->flags |= SRV_F_CHECKPORT;
1635 srv->check.inter = src->check.inter;
1636 srv->check.fastinter = src->check.fastinter;
1637 srv->check.downinter = src->check.downinter;
1638 srv->agent.use_ssl = src->agent.use_ssl;
1639 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001640
1641 if (src->agent.tcpcheck_rules) {
1642 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
1643 if (srv->agent.tcpcheck_rules) {
1644 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
1645 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
1646 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
1647 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
1648 &src->agent.tcpcheck_rules->preset_vars);
1649 }
1650 }
1651
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001652 srv->agent.inter = src->agent.inter;
1653 srv->agent.fastinter = src->agent.fastinter;
1654 srv->agent.downinter = src->agent.downinter;
1655 srv->maxqueue = src->maxqueue;
1656 srv->minconn = src->minconn;
1657 srv->maxconn = src->maxconn;
1658 srv->slowstart = src->slowstart;
1659 srv->observe = src->observe;
1660 srv->onerror = src->onerror;
1661 srv->onmarkeddown = src->onmarkeddown;
1662 srv->onmarkedup = src->onmarkedup;
1663 if (src->trackit != NULL)
1664 srv->trackit = strdup(src->trackit);
1665 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1666 srv->uweight = srv->iweight = src->iweight;
1667
1668 srv->check.send_proxy = src->check.send_proxy;
1669 /* health: up, but will fall down at first failure */
1670 srv->check.rise = srv->check.health = src->check.rise;
1671 srv->check.fall = src->check.fall;
1672
1673 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001674 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1675 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1676 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001677 srv->check.state |= CHK_ST_PAUSED;
1678 srv->check.health = 0;
1679 }
1680
1681 /* health: up but will fall down at first failure */
1682 srv->agent.rise = srv->agent.health = src->agent.rise;
1683 srv->agent.fall = src->agent.fall;
1684
1685 if (src->resolvers_id != NULL)
1686 srv->resolvers_id = strdup(src->resolvers_id);
1687 srv->dns_opts.family_prio = src->dns_opts.family_prio;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02001688 srv->dns_opts.accept_duplicate_ip = src->dns_opts.accept_duplicate_ip;
Daniel Corbettf8716912019-11-17 09:48:56 -05001689 srv->dns_opts.ignore_weight = src->dns_opts.ignore_weight;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001690 if (srv->dns_opts.family_prio == AF_UNSPEC)
1691 srv->dns_opts.family_prio = AF_INET6;
1692 memcpy(srv->dns_opts.pref_net,
1693 src->dns_opts.pref_net,
1694 sizeof srv->dns_opts.pref_net);
1695 srv->dns_opts.pref_net_nb = src->dns_opts.pref_net_nb;
1696
1697 srv->init_addr_methods = src->init_addr_methods;
1698 srv->init_addr = src->init_addr;
1699#if defined(USE_OPENSSL)
1700 srv_ssl_settings_cpy(srv, src);
1701#endif
1702#ifdef TCP_USER_TIMEOUT
1703 srv->tcp_ut = src->tcp_ut;
1704#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001705 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001706 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001707 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01001708 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01001709 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001710
Olivier Houchard8da5f982017-08-04 18:35:36 +02001711 if (srv_tmpl)
1712 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001713
1714 srv->check.via_socks4 = src->check.via_socks4;
1715 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001716}
1717
William Lallemand313bfd12018-10-26 14:47:32 +02001718struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001719{
1720 struct server *srv;
1721
1722 srv = calloc(1, sizeof *srv);
1723 if (!srv)
1724 return NULL;
1725
1726 srv->obj_type = OBJ_TYPE_SERVER;
1727 srv->proxy = proxy;
1728 LIST_INIT(&srv->actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04001729 srv->pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02001730
Emeric Brun52a91d32017-08-31 14:41:55 +02001731 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001732 srv->last_change = now.tv_sec;
1733
Christopher Faulet38290462020-04-21 11:46:40 +02001734 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001735 srv->check.status = HCHK_STATUS_INI;
1736 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01001737 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02001738 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001739
Christopher Faulet38290462020-04-21 11:46:40 +02001740 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001741 srv->agent.status = HCHK_STATUS_INI;
1742 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01001743 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001744 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
1745
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01001746 srv->extra_counters = NULL;
1747
Willy Tarreau975b1552019-06-06 16:25:55 +02001748 /* please don't put default server settings here, they are set in
1749 * init_default_instance().
1750 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001751 return srv;
1752}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001753
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001754#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1755static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
1756 struct server *srv, struct proxy *proxy)
1757{
1758 int ret;
1759 char *err = NULL;
1760
1761 if (!srv->sni_expr)
1762 return 0;
1763
1764 ret = server_parse_sni_expr(srv, proxy, &err);
1765 if (!ret)
1766 return 0;
1767
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001768 display_parser_err(file, linenum, args, cur_arg, ret, &err);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001769 free(err);
1770
1771 return ret;
1772}
1773#endif
1774
1775/*
1776 * Server initializations finalization.
1777 * Initialize health check, agent check and SNI expression if enabled.
1778 * Must not be called for a default server instance.
1779 */
1780static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
1781 struct server *srv, struct proxy *px)
1782{
Christopher Fauletb3b53522020-04-27 11:17:10 +02001783#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001784 int ret;
Christopher Fauletb3b53522020-04-27 11:17:10 +02001785#endif
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001786
Christopher Faulet8892e5d2020-03-26 19:48:20 +01001787 if (srv->do_check && srv->trackit) {
1788 ha_alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1789 file, linenum);
1790 return ERR_ALERT | ERR_FATAL;
1791 }
1792
1793 if (srv->do_agent && !srv->agent.port) {
1794 ha_alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
1795 file, linenum, srv->id);
1796 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001797 }
1798
1799#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1800 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
1801 return ret;
1802#endif
1803
1804 if (srv->flags & SRV_F_BACKUP)
1805 px->srv_bck++;
1806 else
1807 px->srv_act++;
1808 srv_lb_commit_status(srv);
1809
1810 return 0;
1811}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001812
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001813/*
1814 * Parse as much as possible such a range string argument: low[-high]
1815 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
1816 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
1817 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
1818 * Returns 0 if succeeded, -1 if not.
1819 */
1820static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
1821{
1822 char *nb_high_arg;
1823
1824 *nb_high = 0;
1825 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001826 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001827
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001828 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001829 *nb_high_arg++ = '\0';
1830 *nb_high = atoi(nb_high_arg);
1831 }
1832 else {
1833 *nb_high += *nb_low;
1834 *nb_low = 1;
1835 }
1836
1837 if (*nb_low < 0 || *nb_high < *nb_low)
1838 return -1;
1839
1840 return 0;
1841}
1842
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001843static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
1844{
1845 chunk_printf(&trash, "%s%d", prefix, nb);
1846 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001847 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001848}
1849
1850/*
1851 * Initialize as much as possible servers from <srv> server template.
1852 * Note that a server template is a special server with
1853 * a few different parameters than a server which has
1854 * been parsed mostly the same way as a server.
Joseph Herlant44466822018-11-15 08:57:51 -08001855 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001856 * 'srv' template included.
1857 */
1858static int server_template_init(struct server *srv, struct proxy *px)
1859{
1860 int i;
1861 struct server *newsrv;
1862
1863 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 +02001864 newsrv = new_server(px);
1865 if (!newsrv)
1866 goto err;
1867
Christopher Faulet75bef002020-11-02 22:04:55 +01001868 newsrv->conf.file = strdup(srv->conf.file);
1869 newsrv->conf.line = srv->conf.line;
1870
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001871 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001872 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001873#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1874 if (newsrv->sni_expr) {
1875 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
1876 if (!newsrv->ssl_ctx.sni)
1877 goto err;
1878 }
1879#endif
1880 /* Set this new server ID. */
1881 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
1882
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001883 /* Linked backwards first. This will be restablished after parsing. */
1884 newsrv->next = px->srv;
1885 px->srv = newsrv;
1886 }
1887 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1888
1889 return i - srv->tmpl_info.nb_low;
1890
1891 err:
1892 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1893 if (newsrv) {
1894#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1895 release_sample_expr(newsrv->ssl_ctx.sni);
1896#endif
1897 free_check(&newsrv->agent);
1898 free_check(&newsrv->check);
1899 }
1900 free(newsrv);
1901 return i - srv->tmpl_info.nb_low;
1902}
1903
Emeric Brund3db3842020-07-21 16:54:36 +02001904int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy,
1905 struct proxy *defproxy, int parse_addr, int in_peers_section, int initial_resolve)
Willy Tarreau272adea2014-03-31 10:39:59 +02001906{
1907 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001908 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001909 char *errmsg = NULL;
1910 int err_code = 0;
1911 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02001912 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001913
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001914 if (!strcmp(args[0], "server") ||
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02001915 !strcmp(args[0], "peer") ||
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001916 !strcmp(args[0], "default-server") ||
1917 !strcmp(args[0], "server-template")) {
Willy Tarreau272adea2014-03-31 10:39:59 +02001918 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001919 int defsrv = (*args[0] == 'd');
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02001920 int srv = !defsrv && (*args[0] == 'p' || !strcmp(args[0], "server"));
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001921 int srv_tmpl = !defsrv && !srv;
1922 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02001923
1924 if (!defsrv && curproxy == defproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001925 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001926 err_code |= ERR_ALERT | ERR_FATAL;
1927 goto out;
1928 }
1929 else if (warnifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL))
Olivier Houchard306e6532018-07-24 16:48:59 +02001930 err_code |= ERR_WARN;
Willy Tarreau272adea2014-03-31 10:39:59 +02001931
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001932 /* There is no mandatory first arguments for default server. */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01001933 if (srv && parse_addr) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001934 if (!*args[2]) {
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +02001935 if (in_peers_section) {
1936 return 0;
1937 }
1938 else {
1939 /* 'server' line number of argument check. */
1940 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1941 file, linenum, args[0]);
1942 err_code |= ERR_ALERT | ERR_FATAL;
1943 goto out;
1944 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001945 }
1946
1947 err = invalid_char(args[1]);
1948 }
1949 else if (srv_tmpl) {
1950 if (!*args[3]) {
1951 /* 'server-template' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001952 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 +02001953 file, linenum, args[0]);
1954 err_code |= ERR_ALERT | ERR_FATAL;
1955 goto out;
1956 }
1957
1958 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001959 }
1960
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001961 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001962 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 +02001963 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001964 err_code |= ERR_ALERT | ERR_FATAL;
1965 goto out;
1966 }
1967
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001968 cur_arg = 2;
1969 if (srv_tmpl) {
1970 /* Parse server-template <nb | range> arg. */
1971 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001972 ha_alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001973 file, linenum, args[0], args[cur_arg]);
1974 err_code |= ERR_ALERT | ERR_FATAL;
1975 goto out;
1976 }
1977 cur_arg++;
1978 }
1979
Willy Tarreau272adea2014-03-31 10:39:59 +02001980 if (!defsrv) {
1981 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01001982 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02001983
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001984 newsrv = new_server(curproxy);
1985 if (!newsrv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001986 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Willy Tarreau272adea2014-03-31 10:39:59 +02001987 err_code |= ERR_ALERT | ERR_ABORT;
1988 goto out;
1989 }
1990
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001991 if (srv_tmpl) {
1992 newsrv->tmpl_info.nb_low = tmpl_range_low;
1993 newsrv->tmpl_info.nb_high = tmpl_range_high;
1994 }
1995
Willy Tarreau272adea2014-03-31 10:39:59 +02001996 /* the servers are linked backwards first */
1997 newsrv->next = curproxy->srv;
1998 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02001999 newsrv->conf.file = strdup(file);
2000 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002001 /* Note: for a server template, its id is its prefix.
2002 * This is a temporary id which will be used for server allocations to come
2003 * after parsing.
2004 */
2005 if (srv)
2006 newsrv->id = strdup(args[1]);
2007 else
2008 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002009
2010 /* several ways to check the port component :
2011 * - IP => port=+0, relative (IPv4 only)
2012 * - IP: => port=+0, relative
2013 * - IP:N => port=N, absolute
2014 * - IP:+N => port=+N, relative
2015 * - IP:-N => port=-N, relative
2016 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002017 if (!parse_addr)
2018 goto skip_addr;
2019
Willy Tarreau65ec4e32020-09-16 19:17:08 +02002020 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, NULL, NULL,
2021 &errmsg, NULL, &fqdn,
2022 (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 +02002023 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002024 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau272adea2014-03-31 10:39:59 +02002025 err_code |= ERR_ALERT | ERR_FATAL;
2026 goto out;
2027 }
2028
Willy Tarreau272adea2014-03-31 10:39:59 +02002029 if (!port1 || !port2) {
2030 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002031 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002032 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002033
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002034 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002035 if (fqdn) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002036 if (fqdn[0] == '_') { /* SRV record */
Olivier Houchard8da5f982017-08-04 18:35:36 +02002037 /* Check if a SRV request already exists, and if not, create it */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002038 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
2039 newsrv->srvrq = new_dns_srvrq(newsrv, fqdn);
2040 if (newsrv->srvrq == NULL) {
Olivier Houchard8da5f982017-08-04 18:35:36 +02002041 err_code |= ERR_ALERT | ERR_FATAL;
2042 goto out;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002043 }
2044 }
2045 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002046 ha_alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
Christopher Faulet67957bd2017-09-27 11:00:59 +02002047 file, linenum, newsrv->id);
2048 err_code |= ERR_ALERT | ERR_FATAL;
2049 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002050 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002051 }
2052
Willy Tarreau272adea2014-03-31 10:39:59 +02002053 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002054 newsrv->svc_port = port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002055
Olivier Houchard8da5f982017-08-04 18:35:36 +02002056 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002057 ha_alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002058 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002059 err_code |= ERR_ALERT | ERR_FATAL;
2060 goto out;
2061 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002062
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002063 cur_arg++;
2064 skip_addr:
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002065 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002066 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002067 HA_SPIN_INIT(&newsrv->lock);
Willy Tarreau272adea2014-03-31 10:39:59 +02002068 } else {
2069 newsrv = &curproxy->defsrv;
2070 cur_arg = 1;
Thierry Fournierada34842016-02-17 21:25:09 +01002071 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002072 newsrv->dns_opts.accept_duplicate_ip = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002073 }
2074
2075 while (*args[cur_arg]) {
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002076 if (!strcmp(args[cur_arg], "init-addr")) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002077 char *p, *end;
2078 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002079 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002080
2081 newsrv->init_addr_methods = 0;
2082 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2083
2084 for (p = args[cur_arg + 1]; *p; p = end) {
2085 /* cut on next comma */
2086 for (end = p; *end && *end != ','; end++);
2087 if (*end)
2088 *(end++) = 0;
2089
Willy Tarreau4310d362016-11-02 15:05:56 +01002090 memset(&sa, 0, sizeof(sa));
Baptiste Assmann25938272016-09-21 20:26:16 +02002091 if (!strcmp(p, "libc")) {
2092 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2093 }
2094 else if (!strcmp(p, "last")) {
2095 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2096 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01002097 else if (!strcmp(p, "none")) {
2098 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2099 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002100 else if (str2ip2(p, &sa, 0)) {
2101 if (is_addr(&newsrv->init_addr)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002102 ha_alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
Willy Tarreau4310d362016-11-02 15:05:56 +01002103 file, linenum, args[cur_arg], p);
2104 err_code |= ERR_ALERT | ERR_FATAL;
2105 goto out;
2106 }
2107 newsrv->init_addr = sa;
2108 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2109 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002110 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002111 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 +02002112 file, linenum, args[cur_arg], p);
2113 err_code |= ERR_ALERT | ERR_FATAL;
2114 goto out;
2115 }
2116 if (!done) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002117 ha_alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002118 file, linenum, args[cur_arg], p);
2119 err_code |= ERR_ALERT | ERR_FATAL;
2120 goto out;
2121 }
2122 }
2123 cur_arg += 2;
2124 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002125 else if (!strcmp(args[cur_arg], "resolvers")) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002126 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002127 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2128 cur_arg += 2;
2129 }
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002130 else if (!strcmp(args[cur_arg], "resolve-opts")) {
2131 char *p, *end;
2132
2133 for (p = args[cur_arg + 1]; *p; p = end) {
2134 /* cut on next comma */
2135 for (end = p; *end && *end != ','; end++);
2136 if (*end)
2137 *(end++) = 0;
2138
2139 if (!strcmp(p, "allow-dup-ip")) {
2140 newsrv->dns_opts.accept_duplicate_ip = 1;
2141 }
Daniel Corbettf8716912019-11-17 09:48:56 -05002142 else if (!strcmp(p, "ignore-weight")) {
2143 newsrv->dns_opts.ignore_weight = 1;
2144 }
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002145 else if (!strcmp(p, "prevent-dup-ip")) {
2146 newsrv->dns_opts.accept_duplicate_ip = 0;
2147 }
2148 else {
Daniel Corbettf8716912019-11-17 09:48:56 -05002149 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 +02002150 file, linenum, args[cur_arg], p);
2151 err_code |= ERR_ALERT | ERR_FATAL;
2152 goto out;
2153 }
2154 }
2155
2156 cur_arg += 2;
2157 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002158 else if (!strcmp(args[cur_arg], "resolve-prefer")) {
2159 if (!strcmp(args[cur_arg + 1], "ipv4"))
Thierry Fournierada34842016-02-17 21:25:09 +01002160 newsrv->dns_opts.family_prio = AF_INET;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002161 else if (!strcmp(args[cur_arg + 1], "ipv6"))
Thierry Fournierada34842016-02-17 21:25:09 +01002162 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002163 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002164 ha_alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002165 file, linenum, args[cur_arg]);
2166 err_code |= ERR_ALERT | ERR_FATAL;
2167 goto out;
2168 }
2169 cur_arg += 2;
2170 }
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002171 else if (!strcmp(args[cur_arg], "resolve-net")) {
2172 char *p, *e;
2173 unsigned char mask;
2174 struct dns_options *opt;
2175
2176 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002177 ha_alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002178 file, linenum, args[cur_arg]);
2179 err_code |= ERR_ALERT | ERR_FATAL;
2180 goto out;
2181 }
2182
2183 opt = &newsrv->dns_opts;
2184
2185 /* Split arguments by comma, and convert it from ipv4 or ipv6
2186 * string network in in_addr or in6_addr.
2187 */
2188 p = args[cur_arg + 1];
2189 e = p;
2190 while (*p != '\0') {
Joseph Herlant44466822018-11-15 08:57:51 -08002191 /* If no room available, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002192 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002193 ha_alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002194 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2195 err_code |= ERR_ALERT | ERR_FATAL;
2196 goto out;
2197 }
2198 /* look for end or comma. */
2199 while (*e != ',' && *e != '\0')
2200 e++;
2201 if (*e == ',') {
2202 *e = '\0';
2203 e++;
2204 }
2205 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2206 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2207 /* Try to convert input string from ipv4 or ipv6 network. */
2208 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2209 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2210 &mask)) {
2211 /* Try to convert input string from ipv6 network. */
2212 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2213 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2214 } else {
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002215 /* All network conversions fail, return error. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002216 ha_alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002217 file, linenum, args[cur_arg], p);
2218 err_code |= ERR_ALERT | ERR_FATAL;
2219 goto out;
2220 }
2221 opt->pref_net_nb++;
2222 p = e;
2223 }
2224
2225 cur_arg += 2;
2226 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002227 else if (!strcmp(args[cur_arg], "weight")) {
2228 int w;
2229 w = atol(args[cur_arg + 1]);
2230 if (w < 0 || w > SRV_UWGHT_MAX) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002231 ha_alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002232 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2233 err_code |= ERR_ALERT | ERR_FATAL;
2234 goto out;
2235 }
2236 newsrv->uweight = newsrv->iweight = w;
2237 cur_arg += 2;
2238 }
Emeric Brun97556472020-05-30 01:42:45 +02002239 else if (!strcmp(args[cur_arg], "log-proto")) {
2240 if (!strcmp(args[cur_arg + 1], "legacy"))
2241 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
2242 else if (!strcmp(args[cur_arg + 1], "octet-count"))
2243 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
2244 else {
2245 ha_alert("parsing [%s:%d]: '%s' expects one of 'legacy' or "
2246 "'octet-count' but got '%s'\n",
2247 file, linenum, args[cur_arg], args[cur_arg + 1]);
2248 err_code |= ERR_ALERT | ERR_FATAL;
2249 goto out;
2250 }
2251 cur_arg += 2;
2252 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002253 else if (!strcmp(args[cur_arg], "minconn")) {
2254 newsrv->minconn = atol(args[cur_arg + 1]);
2255 cur_arg += 2;
2256 }
2257 else if (!strcmp(args[cur_arg], "maxconn")) {
2258 newsrv->maxconn = atol(args[cur_arg + 1]);
2259 cur_arg += 2;
2260 }
2261 else if (!strcmp(args[cur_arg], "maxqueue")) {
2262 newsrv->maxqueue = atol(args[cur_arg + 1]);
2263 cur_arg += 2;
2264 }
2265 else if (!strcmp(args[cur_arg], "slowstart")) {
2266 /* slowstart is stored in seconds */
2267 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02002268
2269 if (err == PARSE_TIME_OVER) {
2270 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).\n",
2271 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2272 err_code |= ERR_ALERT | ERR_FATAL;
2273 goto out;
2274 }
2275 else if (err == PARSE_TIME_UNDER) {
2276 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.\n",
2277 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2278 err_code |= ERR_ALERT | ERR_FATAL;
2279 goto out;
2280 }
2281 else if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002282 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002283 file, linenum, *err, newsrv->id);
2284 err_code |= ERR_ALERT | ERR_FATAL;
2285 goto out;
2286 }
2287 newsrv->slowstart = (val + 999) / 1000;
2288 cur_arg += 2;
2289 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002290 else if (!strcmp(args[cur_arg], "on-error")) {
2291 if (!strcmp(args[cur_arg + 1], "fastinter"))
2292 newsrv->onerror = HANA_ONERR_FASTINTER;
2293 else if (!strcmp(args[cur_arg + 1], "fail-check"))
2294 newsrv->onerror = HANA_ONERR_FAILCHK;
2295 else if (!strcmp(args[cur_arg + 1], "sudden-death"))
2296 newsrv->onerror = HANA_ONERR_SUDDTH;
2297 else if (!strcmp(args[cur_arg + 1], "mark-down"))
2298 newsrv->onerror = HANA_ONERR_MARKDWN;
2299 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002300 ha_alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
Willy Tarreau272adea2014-03-31 10:39:59 +02002301 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2302 file, linenum, args[cur_arg], args[cur_arg + 1]);
2303 err_code |= ERR_ALERT | ERR_FATAL;
2304 goto out;
2305 }
2306
2307 cur_arg += 2;
2308 }
2309 else if (!strcmp(args[cur_arg], "on-marked-down")) {
2310 if (!strcmp(args[cur_arg + 1], "shutdown-sessions"))
2311 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2312 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002313 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002314 file, linenum, args[cur_arg], args[cur_arg + 1]);
2315 err_code |= ERR_ALERT | ERR_FATAL;
2316 goto out;
2317 }
2318
2319 cur_arg += 2;
2320 }
2321 else if (!strcmp(args[cur_arg], "on-marked-up")) {
2322 if (!strcmp(args[cur_arg + 1], "shutdown-backup-sessions"))
2323 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2324 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002325 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002326 file, linenum, args[cur_arg], args[cur_arg + 1]);
2327 err_code |= ERR_ALERT | ERR_FATAL;
2328 goto out;
2329 }
2330
2331 cur_arg += 2;
2332 }
2333 else if (!strcmp(args[cur_arg], "error-limit")) {
2334 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002335 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002336 file, linenum, args[cur_arg]);
2337 err_code |= ERR_ALERT | ERR_FATAL;
2338 goto out;
2339 }
2340
2341 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2342
2343 if (newsrv->consecutive_errors_limit <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002344 ha_alert("parsing [%s:%d]: %s has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002345 file, linenum, args[cur_arg]);
2346 err_code |= ERR_ALERT | ERR_FATAL;
2347 goto out;
2348 }
2349 cur_arg += 2;
2350 }
Frédéric Lécaille8d083ed2017-04-14 15:19:56 +02002351 else if (!strcmp(args[cur_arg], "usesrc")) { /* address to use outside: needs "source" first */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002352 ha_alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002353 file, linenum, "usesrc", "source");
2354 err_code |= ERR_ALERT | ERR_FATAL;
2355 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002356 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002357 else {
2358 static int srv_dumped;
2359 struct srv_kw *kw;
2360 char *err;
2361
2362 kw = srv_find_kw(args[cur_arg]);
2363 if (kw) {
2364 char *err = NULL;
2365 int code;
2366
2367 if (!kw->parse) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002368 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 +02002369 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002370 if (kw->skip != -1)
2371 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002372 err_code |= ERR_ALERT | ERR_FATAL;
2373 goto out;
2374 }
2375
2376 if (defsrv && !kw->default_ok) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002377 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002378 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002379 if (kw->skip != -1)
2380 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002381 err_code |= ERR_ALERT;
2382 continue;
2383 }
2384
2385 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2386 err_code |= code;
2387
2388 if (code) {
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002389 display_parser_err(file, linenum, args, cur_arg, code, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002390 if (code & ERR_FATAL) {
2391 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002392 if (kw->skip != -1)
2393 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002394 goto out;
2395 }
2396 }
2397 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002398 if (kw->skip != -1)
2399 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002400 continue;
2401 }
2402
2403 err = NULL;
2404 if (!srv_dumped) {
2405 srv_dump_kws(&err);
2406 indent_msg(&err, 4);
2407 srv_dumped = 1;
2408 }
2409
Christopher Faulet767a84b2017-11-24 16:50:31 +01002410 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002411 file, linenum, args[0], args[1], args[cur_arg],
2412 err ? " Registered keywords :" : "", err ? err : "");
2413 free(err);
2414
2415 err_code |= ERR_ALERT | ERR_FATAL;
2416 goto out;
2417 }
2418 }
2419
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002420 if (!defsrv)
2421 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2422 if (err_code & ERR_FATAL)
2423 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002424 if (srv_tmpl)
2425 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002426 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002427 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002428 return 0;
2429
2430 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002431 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002432 free(errmsg);
2433 return err_code;
2434}
2435
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002436/* Returns a pointer to the first server matching either id <id>.
2437 * NULL is returned if no match is found.
2438 * the lookup is performed in the backend <bk>
2439 */
2440struct server *server_find_by_id(struct proxy *bk, int id)
2441{
2442 struct eb32_node *eb32;
2443 struct server *curserver;
2444
2445 if (!bk || (id ==0))
2446 return NULL;
2447
2448 /* <bk> has no backend capabilities, so it can't have a server */
2449 if (!(bk->cap & PR_CAP_BE))
2450 return NULL;
2451
2452 curserver = NULL;
2453
2454 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2455 if (eb32)
2456 curserver = container_of(eb32, struct server, conf.id);
2457
2458 return curserver;
2459}
2460
2461/* Returns a pointer to the first server matching either name <name>, or id
2462 * if <name> starts with a '#'. NULL is returned if no match is found.
2463 * the lookup is performed in the backend <bk>
2464 */
2465struct server *server_find_by_name(struct proxy *bk, const char *name)
2466{
2467 struct server *curserver;
2468
2469 if (!bk || !name)
2470 return NULL;
2471
2472 /* <bk> has no backend capabilities, so it can't have a server */
2473 if (!(bk->cap & PR_CAP_BE))
2474 return NULL;
2475
2476 curserver = NULL;
2477 if (*name == '#') {
2478 curserver = server_find_by_id(bk, atoi(name + 1));
2479 if (curserver)
2480 return curserver;
2481 }
2482 else {
2483 curserver = bk->srv;
2484
2485 while (curserver && (strcmp(curserver->id, name) != 0))
2486 curserver = curserver->next;
2487
2488 if (curserver)
2489 return curserver;
2490 }
2491
2492 return NULL;
2493}
2494
2495struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2496{
2497 struct server *byname;
2498 struct server *byid;
2499
2500 if (!name && !id)
2501 return NULL;
2502
2503 if (diff)
2504 *diff = 0;
2505
2506 byname = byid = NULL;
2507
2508 if (name) {
2509 byname = server_find_by_name(bk, name);
2510 if (byname && (!id || byname->puid == id))
2511 return byname;
2512 }
2513
2514 /* remaining possibilities :
2515 * - name not set
2516 * - name set but not found
2517 * - name found but ID doesn't match
2518 */
2519 if (id) {
2520 byid = server_find_by_id(bk, id);
2521 if (byid) {
2522 if (byname) {
2523 /* use id only if forced by configuration */
2524 if (byid->flags & SRV_F_FORCED_ID) {
2525 if (diff)
2526 *diff |= 2;
2527 return byid;
2528 }
2529 else {
2530 if (diff)
2531 *diff |= 1;
2532 return byname;
2533 }
2534 }
2535
2536 /* remaining possibilities:
2537 * - name not set
2538 * - name set but not found
2539 */
2540 if (name && diff)
2541 *diff |= 2;
2542 return byid;
2543 }
2544
2545 /* id bot found */
2546 if (byname) {
2547 if (diff)
2548 *diff |= 1;
2549 return byname;
2550 }
2551 }
2552
2553 return NULL;
2554}
2555
Willy Tarreau46b7f532018-08-21 11:54:26 +02002556/* Update a server state using the parameters available in the params list.
2557 *
2558 * Grabs the server lock during operation.
2559 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002560static void srv_update_state(struct server *srv, int version, char **params)
2561{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002562 char *p;
Willy Tarreau83061a82018-07-13 11:56:34 +02002563 struct buffer *msg;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002564
2565 /* fields since version 1
2566 * and common to all other upcoming versions
2567 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002568 enum srv_state srv_op_state;
2569 enum srv_admin srv_admin_state;
2570 unsigned srv_uweight, srv_iweight;
2571 unsigned long srv_last_time_change;
2572 short srv_check_status;
2573 enum chk_result srv_check_result;
2574 int srv_check_health;
2575 int srv_check_state, srv_agent_state;
2576 int bk_f_forced_id;
2577 int srv_f_forced_id;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002578 int fqdn_set_by_cli;
2579 const char *fqdn;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002580 const char *port_str;
2581 unsigned int port;
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002582 char *srvrecord;
William Dauchyf6370442020-11-14 19:25:33 +01002583#ifdef USE_OPENSSL
2584 int use_ssl;
2585#endif
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002586
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002587 fqdn = NULL;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002588 port = 0;
Willy Tarreau31138fa2015-09-29 18:38:47 +02002589 msg = get_trash_chunk();
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002590 switch (version) {
2591 case 1:
2592 /*
2593 * now we can proceed with server's state update:
2594 * srv_addr: params[0]
2595 * srv_op_state: params[1]
2596 * srv_admin_state: params[2]
2597 * srv_uweight: params[3]
2598 * srv_iweight: params[4]
2599 * srv_last_time_change: params[5]
2600 * srv_check_status: params[6]
2601 * srv_check_result: params[7]
2602 * srv_check_health: params[8]
2603 * srv_check_state: params[9]
2604 * srv_agent_state: params[10]
2605 * bk_f_forced_id: params[11]
2606 * srv_f_forced_id: params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002607 * srv_fqdn: params[13]
Frédéric Lécaille31694712017-08-01 08:47:19 +02002608 * srv_port: params[14]
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002609 * srvrecord: params[15]
William Dauchyf6370442020-11-14 19:25:33 +01002610 * srv_use_ssl: params[16]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002611 */
2612
2613 /* validating srv_op_state */
2614 p = NULL;
2615 errno = 0;
2616 srv_op_state = strtol(params[1], &p, 10);
2617 if ((p == params[1]) || errno == EINVAL || errno == ERANGE ||
2618 (srv_op_state != SRV_ST_STOPPED &&
2619 srv_op_state != SRV_ST_STARTING &&
2620 srv_op_state != SRV_ST_RUNNING &&
2621 srv_op_state != SRV_ST_STOPPING)) {
2622 chunk_appendf(msg, ", invalid srv_op_state value '%s'", params[1]);
2623 }
2624
2625 /* validating srv_admin_state */
2626 p = NULL;
2627 errno = 0;
2628 srv_admin_state = strtol(params[2], &p, 10);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002629 fqdn_set_by_cli = !!(srv_admin_state & SRV_ADMF_HMAINT);
Willy Tarreau757478e2016-11-03 19:22:19 +01002630
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002631 /* inherited statuses will be recomputed later.
2632 * Also disable SRV_ADMF_HMAINT flag (set from stats socket fqdn).
2633 */
2634 srv_admin_state &= ~SRV_ADMF_IDRAIN & ~SRV_ADMF_IMAINT & ~SRV_ADMF_HMAINT;
Willy Tarreau757478e2016-11-03 19:22:19 +01002635
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002636 if ((p == params[2]) || errno == EINVAL || errno == ERANGE ||
2637 (srv_admin_state != 0 &&
2638 srv_admin_state != SRV_ADMF_FMAINT &&
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002639 srv_admin_state != SRV_ADMF_CMAINT &&
2640 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT) &&
Willy Tarreaue1bde142016-11-03 18:33:25 +01002641 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FDRAIN) &&
Willy Tarreau757478e2016-11-03 19:22:19 +01002642 srv_admin_state != SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002643 chunk_appendf(msg, ", invalid srv_admin_state value '%s'", params[2]);
2644 }
2645
2646 /* validating srv_uweight */
2647 p = NULL;
2648 errno = 0;
2649 srv_uweight = strtol(params[3], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002650 if ((p == params[3]) || errno == EINVAL || errno == ERANGE || (srv_uweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002651 chunk_appendf(msg, ", invalid srv_uweight value '%s'", params[3]);
2652
2653 /* validating srv_iweight */
2654 p = NULL;
2655 errno = 0;
2656 srv_iweight = strtol(params[4], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002657 if ((p == params[4]) || errno == EINVAL || errno == ERANGE || (srv_iweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002658 chunk_appendf(msg, ", invalid srv_iweight value '%s'", params[4]);
2659
2660 /* validating srv_last_time_change */
2661 p = NULL;
2662 errno = 0;
2663 srv_last_time_change = strtol(params[5], &p, 10);
2664 if ((p == params[5]) || errno == EINVAL || errno == ERANGE)
2665 chunk_appendf(msg, ", invalid srv_last_time_change value '%s'", params[5]);
2666
2667 /* validating srv_check_status */
2668 p = NULL;
2669 errno = 0;
2670 srv_check_status = strtol(params[6], &p, 10);
2671 if (p == params[6] || errno == EINVAL || errno == ERANGE ||
2672 (srv_check_status >= HCHK_STATUS_SIZE))
2673 chunk_appendf(msg, ", invalid srv_check_status value '%s'", params[6]);
2674
2675 /* validating srv_check_result */
2676 p = NULL;
2677 errno = 0;
2678 srv_check_result = strtol(params[7], &p, 10);
2679 if ((p == params[7]) || errno == EINVAL || errno == ERANGE ||
2680 (srv_check_result != CHK_RES_UNKNOWN &&
2681 srv_check_result != CHK_RES_NEUTRAL &&
2682 srv_check_result != CHK_RES_FAILED &&
2683 srv_check_result != CHK_RES_PASSED &&
2684 srv_check_result != CHK_RES_CONDPASS)) {
2685 chunk_appendf(msg, ", invalid srv_check_result value '%s'", params[7]);
2686 }
2687
2688 /* validating srv_check_health */
2689 p = NULL;
2690 errno = 0;
2691 srv_check_health = strtol(params[8], &p, 10);
2692 if (p == params[8] || errno == EINVAL || errno == ERANGE)
2693 chunk_appendf(msg, ", invalid srv_check_health value '%s'", params[8]);
2694
2695 /* validating srv_check_state */
2696 p = NULL;
2697 errno = 0;
2698 srv_check_state = strtol(params[9], &p, 10);
2699 if (p == params[9] || errno == EINVAL || errno == ERANGE ||
2700 (srv_check_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2701 chunk_appendf(msg, ", invalid srv_check_state value '%s'", params[9]);
2702
2703 /* validating srv_agent_state */
2704 p = NULL;
2705 errno = 0;
2706 srv_agent_state = strtol(params[10], &p, 10);
2707 if (p == params[10] || errno == EINVAL || errno == ERANGE ||
2708 (srv_agent_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2709 chunk_appendf(msg, ", invalid srv_agent_state value '%s'", params[10]);
2710
2711 /* validating bk_f_forced_id */
2712 p = NULL;
2713 errno = 0;
2714 bk_f_forced_id = strtol(params[11], &p, 10);
2715 if (p == params[11] || errno == EINVAL || errno == ERANGE || !((bk_f_forced_id == 0) || (bk_f_forced_id == 1)))
2716 chunk_appendf(msg, ", invalid bk_f_forced_id value '%s'", params[11]);
2717
2718 /* validating srv_f_forced_id */
2719 p = NULL;
2720 errno = 0;
2721 srv_f_forced_id = strtol(params[12], &p, 10);
2722 if (p == params[12] || errno == EINVAL || errno == ERANGE || !((srv_f_forced_id == 0) || (srv_f_forced_id == 1)))
2723 chunk_appendf(msg, ", invalid srv_f_forced_id value '%s'", params[12]);
2724
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002725 /* validating srv_fqdn */
2726 fqdn = params[13];
2727 if (fqdn && *fqdn == '-')
2728 fqdn = NULL;
2729 if (fqdn && (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn))) {
2730 chunk_appendf(msg, ", invalid srv_fqdn value '%s'", params[13]);
2731 fqdn = NULL;
2732 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002733
Frédéric Lécaille31694712017-08-01 08:47:19 +02002734 port_str = params[14];
2735 if (port_str) {
2736 port = strl2uic(port_str, strlen(port_str));
2737 if (port > USHRT_MAX) {
2738 chunk_appendf(msg, ", invalid srv_port value '%s'", port_str);
2739 port_str = NULL;
2740 }
2741 }
2742
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002743 /* SRV record
2744 * NOTE: in HAProxy, SRV records must start with an underscore '_'
2745 */
2746 srvrecord = params[15];
2747 if (srvrecord && *srvrecord != '_')
2748 srvrecord = NULL;
2749
William Dauchyf6370442020-11-14 19:25:33 +01002750#ifdef USE_OPENSSL
2751 use_ssl = strtol(params[16], &p, 10);
2752#endif
2753
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002754 /* don't apply anything if one error has been detected */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002755 if (msg->data)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002756 goto out;
2757
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002758 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002759 /* recover operational state and apply it to this server
2760 * and all servers tracking this one */
Jérôme Magninf57afa42019-01-20 11:27:40 +01002761 srv->check.health = srv_check_health;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002762 switch (srv_op_state) {
2763 case SRV_ST_STOPPED:
2764 srv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02002765 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002766 break;
2767 case SRV_ST_STARTING:
Jérôme Magninf57afa42019-01-20 11:27:40 +01002768 /* If rise == 1 there is no STARTING state, let's switch to
2769 * RUNNING
2770 */
2771 if (srv->check.rise == 1) {
2772 srv->check.health = srv->check.rise + srv->check.fall - 1;
2773 srv_set_running(srv, "", NULL);
2774 break;
2775 }
2776 if (srv->check.health < 1 || srv->check.health >= srv->check.rise)
2777 srv->check.health = srv->check.rise - 1;
Emeric Brun52a91d32017-08-31 14:41:55 +02002778 srv->next_state = srv_op_state;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002779 break;
2780 case SRV_ST_STOPPING:
Jérôme Magninf57afa42019-01-20 11:27:40 +01002781 /* If fall == 1 there is no STOPPING state, let's switch to
2782 * STOPPED
2783 */
2784 if (srv->check.fall == 1) {
2785 srv->check.health = 0;
2786 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
2787 break;
2788 }
2789 if (srv->check.health < srv->check.rise ||
2790 srv->check.health > srv->check.rise + srv->check.fall - 2)
2791 srv->check.health = srv->check.rise;
Emeric Brun5a133512017-10-19 14:42:30 +02002792 srv_set_stopping(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002793 break;
2794 case SRV_ST_RUNNING:
2795 srv->check.health = srv->check.rise + srv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02002796 srv_set_running(srv, "", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002797 break;
2798 }
2799
2800 /* When applying server state, the following rules apply:
2801 * - in case of a configuration change, we apply the setting from the new
2802 * configuration, regardless of old running state
2803 * - if no configuration change, we apply old running state only if old running
2804 * state is different from new configuration state
2805 */
2806 /* configuration has changed */
Emeric Brun52a91d32017-08-31 14:41:55 +02002807 if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->next_admin & SRV_ADMF_CMAINT)) {
2808 if (srv->next_admin & SRV_ADMF_CMAINT)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002809 srv_adm_set_maint(srv);
2810 else
2811 srv_adm_set_ready(srv);
2812 }
2813 /* configuration is the same, let's compate old running state and new conf state */
2814 else {
Emeric Brun52a91d32017-08-31 14:41:55 +02002815 if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002816 srv_adm_set_maint(srv);
Emeric Brun52a91d32017-08-31 14:41:55 +02002817 else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002818 srv_adm_set_ready(srv);
2819 }
2820 /* apply drain mode if server is currently enabled */
Emeric Brun52a91d32017-08-31 14:41:55 +02002821 if (!(srv->next_admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002822 /* The SRV_ADMF_FDRAIN flag is inherited when srv->iweight is 0
Willy Tarreau22cace22016-11-03 18:19:49 +01002823 * (srv->iweight is the weight set up in configuration).
2824 * There are two possible reasons for FDRAIN to have been present :
2825 * - previous config weight was zero
2826 * - "set server b/s drain" was sent to the CLI
2827 *
2828 * In the first case, we simply want to drop this drain state
2829 * if the new weight is not zero anymore, meaning the administrator
2830 * has intentionally turned the weight back to a positive value to
2831 * enable the server again after an operation. In the second case,
2832 * the drain state was forced on the CLI regardless of the config's
2833 * weight so we don't want a change to the config weight to lose this
2834 * status. What this means is :
2835 * - if previous weight was 0 and new one is >0, drop the DRAIN state.
2836 * - if the previous weight was >0, keep it.
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002837 */
Willy Tarreau22cace22016-11-03 18:19:49 +01002838 if (srv_iweight > 0 || srv->iweight == 0)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002839 srv_adm_set_drain(srv);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002840 }
2841
2842 srv->last_change = date.tv_sec - srv_last_time_change;
2843 srv->check.status = srv_check_status;
2844 srv->check.result = srv_check_result;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002845
2846 /* Only case we want to apply is removing ENABLED flag which could have been
2847 * done by the "disable health" command over the stats socket
2848 */
2849 if ((srv->check.state & CHK_ST_CONFIGURED) &&
2850 (srv_check_state & CHK_ST_CONFIGURED) &&
2851 !(srv_check_state & CHK_ST_ENABLED))
2852 srv->check.state &= ~CHK_ST_ENABLED;
2853
2854 /* Only case we want to apply is removing ENABLED flag which could have been
2855 * done by the "disable agent" command over the stats socket
2856 */
2857 if ((srv->agent.state & CHK_ST_CONFIGURED) &&
2858 (srv_agent_state & CHK_ST_CONFIGURED) &&
2859 !(srv_agent_state & CHK_ST_ENABLED))
2860 srv->agent.state &= ~CHK_ST_ENABLED;
2861
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002862 /* We want to apply the previous 'running' weight (srv_uweight) only if there
2863 * was no change in the configuration: both previous and new iweight are equals
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002864 *
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002865 * It means that a configuration file change has precedence over a unix socket change
2866 * for server's weight
2867 *
2868 * by default, HAProxy applies the following weight when parsing the configuration
2869 * srv->uweight = srv->iweight
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002870 */
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002871 if (srv_iweight == srv->iweight) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002872 srv->uweight = srv_uweight;
2873 }
Willy Tarreau3ff577e2018-08-02 11:48:52 +02002874 server_recalc_eweight(srv, 1);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002875
Willy Tarreaue5a60682016-11-09 14:54:53 +01002876 /* load server IP address */
Daniel Corbett9215ffa2018-05-19 19:43:24 -04002877 if (strcmp(params[0], "-"))
2878 srv->lastaddr = strdup(params[0]);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002879
2880 if (fqdn && srv->hostname) {
2881 if (!strcmp(srv->hostname, fqdn)) {
2882 /* Here we reset the 'set from stats socket FQDN' flag
2883 * to support such transitions:
2884 * Let's say initial FQDN value is foo1 (in configuration file).
2885 * - FQDN changed from stats socket, from foo1 to foo2 value,
2886 * - FQDN changed again from file configuration (with the same previous value
2887 set from stats socket, from foo1 to foo2 value),
2888 * - reload for any other reason than a FQDN modification,
2889 * the configuration file FQDN matches the fqdn server state file value.
2890 * So we must reset the 'set from stats socket FQDN' flag to be consistent with
Joseph Herlant44466822018-11-15 08:57:51 -08002891 * any further FQDN modification.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002892 */
Emeric Brun52a91d32017-08-31 14:41:55 +02002893 srv->next_admin &= ~SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002894 }
2895 else {
2896 /* If the FDQN has been changed from stats socket,
2897 * apply fqdn state file value (which is the value set
2898 * from stats socket).
Baptiste Assmann13a92322019-06-07 09:40:55 +02002899 * Also ensure the runtime resolver will process this resolution.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002900 */
2901 if (fqdn_set_by_cli) {
Olivier Houchardd16bfe62017-10-31 15:21:19 +01002902 srv_set_fqdn(srv, fqdn, 0);
Baptiste Assmann13a92322019-06-07 09:40:55 +02002903 srv->flags &= ~SRV_F_NO_RESOLUTION;
Emeric Brun52a91d32017-08-31 14:41:55 +02002904 srv->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002905 }
2906 }
2907 }
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002908 /* If all the conditions below are validated, this means
2909 * we're evaluating a server managed by SRV resolution
2910 */
2911 else if (fqdn && !srv->hostname && srvrecord) {
2912 int res;
2913
2914 /* we can't apply previous state if SRV record has changed */
2915 if (srv->srvrq && strcmp(srv->srvrq->name, srvrecord) != 0) {
2916 chunk_appendf(msg, ", SRV record mismatch between configuration ('%s') and state file ('%s) for server '%s'. Previous state not applied", srv->srvrq->name, srvrecord, srv->id);
2917 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2918 goto out;
2919 }
2920
2921 /* create or find a SRV resolution for this srv record */
2922 if (srv->srvrq == NULL && (srv->srvrq = find_srvrq_by_name(srvrecord, srv->proxy)) == NULL)
2923 srv->srvrq = new_dns_srvrq(srv, srvrecord);
2924 if (srv->srvrq == NULL) {
2925 chunk_appendf(msg, ", can't create or find SRV resolution '%s' for server '%s'", srvrecord, srv->id);
2926 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2927 goto out;
2928 }
2929
2930 /* prepare DNS resolution for this server */
2931 res = srv_prepare_for_resolution(srv, fqdn);
2932 if (res == -1) {
2933 chunk_appendf(msg, ", can't allocate memory for DNS resolution for server '%s'", srv->id);
2934 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2935 goto out;
2936 }
2937
2938 /* configure check.port accordingly */
2939 if ((srv->check.state & CHK_ST_CONFIGURED) &&
2940 !(srv->flags & SRV_F_CHECKPORT))
2941 srv->check.port = port;
2942
2943 /* Unset SRV_F_MAPPORTS for SRV records.
2944 * SRV_F_MAPPORTS is unfortunately set by parse_server()
2945 * because no ports are provided in the configuration file.
2946 * This is because HAProxy will use the port found into the SRV record.
2947 */
2948 srv->flags &= ~SRV_F_MAPPORTS;
2949 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002950
Frédéric Lécaille31694712017-08-01 08:47:19 +02002951 if (port_str)
2952 srv->svc_port = port;
William Dauchyf6370442020-11-14 19:25:33 +01002953
2954#ifdef USE_OPENSSL
2955 /* configure ssl if connection has been initated at startup */
2956 if (srv->ssl_ctx.ctx != NULL)
2957 ssl_sock_set_srv(srv, use_ssl);
2958#endif
2959
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002960 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Frédéric Lécaille31694712017-08-01 08:47:19 +02002961
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002962 break;
2963 default:
2964 chunk_appendf(msg, ", version '%d' not supported", version);
2965 }
2966
2967 out:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002968 if (msg->data) {
Baptiste Assmann0821bb92016-01-21 00:20:50 +01002969 chunk_appendf(msg, "\n");
Christopher Faulet767a84b2017-11-24 16:50:31 +01002970 ha_warning("server-state application failed for server '%s/%s'%s",
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002971 srv->proxy->id, srv->id, msg->area);
Baptiste Assmann0821bb92016-01-21 00:20:50 +01002972 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002973}
2974
Baptiste Assmannda29fe22019-06-13 13:24:29 +02002975
2976/*
2977 * read next line from file <f> and return the server state version if one found.
2978 * If no version is found, then 0 is returned
2979 * Note that this should be the first read on <f>
2980 */
2981static int srv_state_get_version(FILE *f) {
2982 char buf[2];
2983 int ret;
2984
2985 /* first character of first line of the file must contain the version of the export */
2986 if (fgets(buf, 2, f) == NULL) {
2987 return 0;
2988 }
2989
2990 ret = atoi(buf);
2991 if ((ret < SRV_STATE_FILE_VERSION_MIN) ||
2992 (ret > SRV_STATE_FILE_VERSION_MAX))
2993 return 0;
2994
2995 return ret;
2996}
2997
2998
2999/*
3000 * parses server state line stored in <buf> and supposedly in version <version>.
3001 * Set <params> and <srv_params> accordingly.
3002 * In case of error, params[0] is set to NULL.
3003 */
3004static void srv_state_parse_line(char *buf, const int version, char **params, char **srv_params)
3005{
3006 int buflen, arg, srv_arg;
3007 char *cur, *end;
3008
3009 buflen = strlen(buf);
3010 cur = buf;
3011 end = cur + buflen;
3012
3013 /* we need at least one character */
3014 if (buflen == 0) {
3015 params[0] = NULL;
3016 return;
3017 }
3018
3019 /* ignore blank characters at the beginning of the line */
Willy Tarreau90807112020-02-25 08:16:33 +01003020 while (isspace((unsigned char)*cur))
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003021 ++cur;
3022
3023 /* Ignore empty or commented lines */
3024 if (cur == end || *cur == '#') {
3025 params[0] = NULL;
3026 return;
3027 }
3028
3029 /* truncated lines */
3030 if (buf[buflen - 1] != '\n') {
3031 //ha_warning("server-state file '%s': truncated line\n", filepath);
3032 params[0] = NULL;
3033 return;
3034 }
3035
3036 /* Removes trailing '\n' */
3037 buf[buflen - 1] = '\0';
3038
3039 /* we're now ready to move the line into *srv_params[] */
3040 params[0] = cur;
3041 arg = 1;
3042 srv_arg = 0;
3043 while (*cur && arg < SRV_STATE_FILE_MAX_FIELDS) {
Willy Tarreau90807112020-02-25 08:16:33 +01003044 if (isspace((unsigned char)*cur)) {
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003045 *cur = '\0';
3046 ++cur;
Willy Tarreau90807112020-02-25 08:16:33 +01003047 while (isspace((unsigned char)*cur))
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003048 ++cur;
3049 switch (version) {
3050 case 1:
3051 /*
3052 * srv_addr: params[4] => srv_params[0]
3053 * srv_op_state: params[5] => srv_params[1]
3054 * srv_admin_state: params[6] => srv_params[2]
3055 * srv_uweight: params[7] => srv_params[3]
3056 * srv_iweight: params[8] => srv_params[4]
3057 * srv_last_time_change: params[9] => srv_params[5]
3058 * srv_check_status: params[10] => srv_params[6]
3059 * srv_check_result: params[11] => srv_params[7]
3060 * srv_check_health: params[12] => srv_params[8]
3061 * srv_check_state: params[13] => srv_params[9]
3062 * srv_agent_state: params[14] => srv_params[10]
3063 * bk_f_forced_id: params[15] => srv_params[11]
3064 * srv_f_forced_id: params[16] => srv_params[12]
3065 * srv_fqdn: params[17] => srv_params[13]
3066 * srv_port: params[18] => srv_params[14]
3067 * srvrecord: params[19] => srv_params[15]
3068 */
3069 if (arg >= 4) {
3070 srv_params[srv_arg] = cur;
3071 ++srv_arg;
3072 }
3073 break;
3074 }
3075
3076 params[arg] = cur;
3077 ++arg;
3078 }
3079 else {
3080 ++cur;
3081 }
3082 }
3083
3084 /* if line is incomplete line, then ignore it.
3085 * otherwise, update useful flags */
3086 switch (version) {
3087 case 1:
3088 if (arg < SRV_STATE_FILE_NB_FIELDS_VERSION_1) {
3089 params[0] = NULL;
3090 return;
3091 }
3092 break;
3093 }
3094
3095 return;
3096}
3097
3098
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003099/* This function parses all the proxies and only take care of the backends (since we're looking for server)
3100 * For each proxy, it does the following:
3101 * - opens its server state file (either one or local one)
3102 * - read whole file, line by line
3103 * - analyse each line to check if it matches our current backend:
3104 * - backend name matches
3105 * - backend id matches if id is forced and name doesn't match
3106 * - if the server pointed by the line is found, then state is applied
3107 *
3108 * If the running backend uuid or id differs from the state file, then HAProxy reports
3109 * a warning.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003110 *
3111 * Grabs the server's lock via srv_update_state().
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003112 */
3113void apply_server_state(void)
3114{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003115 char mybuf[SRV_STATE_LINE_MAXLEN];
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003116 char *params[SRV_STATE_FILE_MAX_FIELDS] = {0};
3117 char *srv_params[SRV_STATE_FILE_MAX_FIELDS] = {0};
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003118 int version, global_file_version;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003119 FILE *f;
3120 char *filepath;
3121 char globalfilepath[MAXPATHLEN + 1];
3122 char localfilepath[MAXPATHLEN + 1];
3123 int len, fileopenerr, globalfilepathlen, localfilepathlen;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003124 struct proxy *curproxy, *bk;
3125 struct server *srv;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003126 char *line;
3127 char *bkname, *srvname;
3128 struct state_line *st;
3129 struct ebmb_node *node, *next_node;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003130
Willy Tarreau2d067f92020-07-16 06:40:27 +02003131 f = NULL;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003132 global_file_version = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003133 globalfilepathlen = 0;
3134 /* create the globalfilepath variable */
3135 if (global.server_state_file) {
3136 /* absolute path or no base directory provided */
3137 if ((global.server_state_file[0] == '/') || (!global.server_state_base)) {
3138 len = strlen(global.server_state_file);
3139 if (len > MAXPATHLEN) {
3140 globalfilepathlen = 0;
3141 goto globalfileerror;
3142 }
3143 memcpy(globalfilepath, global.server_state_file, len);
3144 globalfilepath[len] = '\0';
3145 globalfilepathlen = len;
3146 }
3147 else if (global.server_state_base) {
3148 len = strlen(global.server_state_base);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003149 if (len > MAXPATHLEN) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003150 globalfilepathlen = 0;
3151 goto globalfileerror;
3152 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003153 memcpy(globalfilepath, global.server_state_base, len);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003154 globalfilepath[len] = 0;
3155 globalfilepathlen = len;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003156
3157 /* append a slash if needed */
3158 if (!globalfilepathlen || globalfilepath[globalfilepathlen - 1] != '/') {
3159 if (globalfilepathlen + 1 > MAXPATHLEN) {
3160 globalfilepathlen = 0;
3161 goto globalfileerror;
3162 }
3163 globalfilepath[globalfilepathlen++] = '/';
3164 }
3165
3166 len = strlen(global.server_state_file);
3167 if (globalfilepathlen + len > MAXPATHLEN) {
3168 globalfilepathlen = 0;
3169 goto globalfileerror;
3170 }
3171 memcpy(globalfilepath + globalfilepathlen, global.server_state_file, len);
3172 globalfilepathlen += len;
3173 globalfilepath[globalfilepathlen++] = 0;
3174 }
3175 }
3176 globalfileerror:
3177 if (globalfilepathlen == 0)
3178 globalfilepath[0] = '\0';
3179
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003180 /* Load global server state in a tree */
3181 if (globalfilepathlen > 0) {
3182 errno = 0;
3183 f = fopen(globalfilepath, "r");
3184 if (errno)
3185 ha_warning("Can't open global server state file '%s': %s\n", globalfilepath, strerror(errno));
Vedran Furac5d486272019-10-16 14:49:38 +02003186 if (!f)
3187 goto out_load_server_state_in_tree;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003188
3189 global_file_version = srv_state_get_version(f);
3190 if (global_file_version == 0)
3191 goto out_load_server_state_in_tree;
3192
3193 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3194 line = NULL;
3195
3196 line = strdup(mybuf);
3197 if (line == NULL)
3198 continue;
3199
3200 srv_state_parse_line(mybuf, global_file_version, params, srv_params);
3201 if (params[0] == NULL)
Willy Tarreauca7a5af2019-12-20 17:26:27 +01003202 goto nextline;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003203
3204 /* bkname */
3205 bkname = params[1];
3206 /* srvname */
3207 srvname = params[3];
3208
3209 /* key */
3210 chunk_printf(&trash, "%s %s", bkname, srvname);
3211
3212 /* store line in tree */
Willy Tarreau7d6a1fa2019-12-20 17:18:13 +01003213 st = calloc(1, sizeof(*st) + trash.data + 1);
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003214 if (st == NULL) {
3215 goto nextline;
3216 }
Willy Tarreau7d6a1fa2019-12-20 17:18:13 +01003217 memcpy(st->name_name.key, trash.area, trash.data + 1);
Willy Tarreaufd1aa012019-12-20 17:23:40 +01003218 if (ebst_insert(&state_file, &st->name_name) != &st->name_name) {
3219 /* this is a duplicate key, probably a hand-crafted file,
3220 * drop it!
3221 */
3222 goto nextline;
3223 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003224
3225 /* save line */
3226 st->line = line;
3227
3228 continue;
3229
3230 nextline:
3231 /* free up memory in case of error during the processing of the line */
3232 free(line);
3233 }
3234 }
3235 out_load_server_state_in_tree:
3236
Ilya Shipitsindc6e8a92020-07-16 02:02:40 +05003237 if (f) {
3238 fclose(f);
3239 f = NULL;
3240 }
3241
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003242 /* parse all proxies and load states form tree (global file) or from local file */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003243 for (curproxy = proxies_list; curproxy != NULL; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003244 /* servers are only in backends */
3245 if (!(curproxy->cap & PR_CAP_BE))
3246 continue;
3247 fileopenerr = 0;
3248 filepath = NULL;
3249
3250 /* search server state file path and name */
3251 switch (curproxy->load_server_state_from_file) {
3252 /* read servers state from global file */
3253 case PR_SRV_STATE_FILE_GLOBAL:
3254 /* there was an error while generating global server state file path */
3255 if (globalfilepathlen == 0)
3256 continue;
3257 filepath = globalfilepath;
3258 fileopenerr = 1;
3259 break;
3260 /* this backend has its own file */
3261 case PR_SRV_STATE_FILE_LOCAL:
3262 localfilepathlen = 0;
3263 localfilepath[0] = '\0';
3264 len = 0;
3265 /* create the localfilepath variable */
3266 /* absolute path or no base directory provided */
3267 if ((curproxy->server_state_file_name[0] == '/') || (!global.server_state_base)) {
3268 len = strlen(curproxy->server_state_file_name);
3269 if (len > MAXPATHLEN) {
3270 localfilepathlen = 0;
3271 goto localfileerror;
3272 }
3273 memcpy(localfilepath, curproxy->server_state_file_name, len);
3274 localfilepath[len] = '\0';
3275 localfilepathlen = len;
3276 }
3277 else if (global.server_state_base) {
3278 len = strlen(global.server_state_base);
3279 localfilepathlen += len;
3280
3281 if (localfilepathlen > MAXPATHLEN) {
3282 localfilepathlen = 0;
3283 goto localfileerror;
3284 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003285 memcpy(localfilepath, global.server_state_base, len);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003286 localfilepath[localfilepathlen] = 0;
3287
3288 /* append a slash if needed */
3289 if (!localfilepathlen || localfilepath[localfilepathlen - 1] != '/') {
3290 if (localfilepathlen + 1 > MAXPATHLEN) {
3291 localfilepathlen = 0;
3292 goto localfileerror;
3293 }
3294 localfilepath[localfilepathlen++] = '/';
3295 }
3296
3297 len = strlen(curproxy->server_state_file_name);
3298 if (localfilepathlen + len > MAXPATHLEN) {
3299 localfilepathlen = 0;
3300 goto localfileerror;
3301 }
3302 memcpy(localfilepath + localfilepathlen, curproxy->server_state_file_name, len);
3303 localfilepathlen += len;
3304 localfilepath[localfilepathlen++] = 0;
3305 }
3306 filepath = localfilepath;
3307 localfileerror:
3308 if (localfilepathlen == 0)
3309 localfilepath[0] = '\0';
3310
3311 break;
3312 case PR_SRV_STATE_FILE_NONE:
3313 default:
3314 continue;
3315 }
3316
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003317 /* when global file is used, we get data from the tree
3318 * Note that in such case we don't check backend name neither uuid.
3319 * Backend name can't be wrong since it's used as a key to retrieve the server state
3320 * line from the tree.
3321 */
3322 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_GLOBAL) {
3323 struct server *srv = curproxy->srv;
3324 while (srv) {
3325 struct ebmb_node *node;
3326 struct state_line *st;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003327
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003328 chunk_printf(&trash, "%s %s", curproxy->id, srv->id);
3329 node = ebst_lookup(&state_file, trash.area);
3330 if (!node)
3331 goto next;
Dragan Dosencf4fb032015-11-04 23:03:26 +01003332
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003333 st = container_of(node, struct state_line, name_name);
3334 memcpy(mybuf, st->line, strlen(st->line));
3335 mybuf[strlen(st->line)] = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003336
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003337 srv_state_parse_line(mybuf, global_file_version, params, srv_params);
3338 if (params[0] == NULL)
3339 goto next;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003340
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003341 srv_update_state(srv, global_file_version, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003342
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003343 next:
3344 srv = srv->next;
3345 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003346
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003347 continue; /* next proxy in list */
3348 }
3349 else {
3350 /* load 'local' state file */
3351 errno = 0;
3352 f = fopen(filepath, "r");
3353 if (errno && fileopenerr)
3354 ha_warning("Can't open server state file '%s': %s\n", filepath, strerror(errno));
3355 if (!f)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003356 continue;
3357
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003358 mybuf[0] = '\0';
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003359
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003360 /* first character of first line of the file must contain the version of the export */
3361 version = srv_state_get_version(f);
3362 if (version == 0) {
3363 ha_warning("Can't get version of the server state file '%s'\n", filepath);
3364 goto fileclose;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003365 }
3366
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003367 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3368 int bk_f_forced_id = 0;
3369 int check_id = 0;
3370 int check_name = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003371
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003372 srv_state_parse_line(mybuf, version, params, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003373
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003374 if (params[0] == NULL) {
3375 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003376 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003377
3378 /* if line is incomplete line, then ignore it.
3379 * otherwise, update useful flags */
3380 switch (version) {
3381 case 1:
3382 bk_f_forced_id = (atoi(params[15]) & PR_O_FORCED_ID);
3383 check_id = (atoi(params[0]) == curproxy->uuid);
3384 check_name = (strcmp(curproxy->id, params[1]) == 0);
3385 break;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003386 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003387
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003388 bk = curproxy;
3389
3390 /* if backend can't be found, let's continue */
3391 if (!check_id && !check_name)
3392 continue;
3393 else if (!check_id && check_name) {
3394 ha_warning("backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3395 send_log(bk, LOG_NOTICE, "backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3396 }
3397 else if (check_id && !check_name) {
3398 ha_warning("backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3399 send_log(bk, LOG_NOTICE, "backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3400 /* if name doesn't match, we still want to update curproxy if the backend id
3401 * was forced in previous the previous configuration */
3402 if (!bk_f_forced_id)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003403 continue;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003404 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003405
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003406 /* look for the server by its name: param[3] */
3407 srv = server_find_best_match(bk, params[3], 0, NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003408
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003409 if (!srv) {
3410 /* if no server found, then warning and continue with next line */
3411 ha_warning("can't find server '%s' in backend '%s'\n",
3412 params[3], params[1]);
3413 send_log(bk, LOG_NOTICE, "can't find server '%s' in backend '%s'\n",
3414 params[3], params[1]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003415 continue;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003416 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003417
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003418 /* now we can proceed with server's state update */
3419 srv_update_state(srv, version, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003420 }
Ilya Shipitsindc6e8a92020-07-16 02:02:40 +05003421
3422 fileclose:
3423 fclose(f);
3424
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003425 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003426 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003427
3428 /* now free memory allocated for the tree */
3429 for (node = ebmb_first(&state_file), next_node = node ? ebmb_next(node) : NULL;
3430 node;
3431 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
3432 st = container_of(node, struct state_line, name_name);
3433 ebmb_delete(&st->name_name);
3434 free(st->line);
3435 free(st);
3436 }
3437
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003438}
3439
Simon Horman7d09b9a2013-02-12 10:45:51 +09003440/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02003441 * update a server's current IP address.
3442 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
3443 * ip is in network format.
3444 * updater is a string which contains an information about the requester of the update.
3445 * updater is used if not NULL.
3446 *
3447 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003448 *
3449 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02003450 */
Thierry Fournierd35b7a62016-02-24 08:23:22 +01003451int update_server_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02003452{
Christopher Fauletd6c6b5f2020-09-08 10:27:24 +02003453 /* save the new IP family & address if necessary */
3454 switch (ip_sin_family) {
3455 case AF_INET:
3456 if (s->addr.ss_family == ip_sin_family &&
3457 !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
3458 return 0;
3459 break;
3460 case AF_INET6:
3461 if (s->addr.ss_family == ip_sin_family &&
3462 !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
3463 return 0;
3464 break;
3465 };
3466
Baptiste Assmann14e40142015-04-14 01:13:07 +02003467 /* generates a log line and a warning on stderr */
3468 if (1) {
3469 /* book enough space for both IPv4 and IPv6 */
3470 char oldip[INET6_ADDRSTRLEN];
3471 char newip[INET6_ADDRSTRLEN];
3472
3473 memset(oldip, '\0', INET6_ADDRSTRLEN);
3474 memset(newip, '\0', INET6_ADDRSTRLEN);
3475
3476 /* copy old IP address in a string */
3477 switch (s->addr.ss_family) {
3478 case AF_INET:
3479 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
3480 break;
3481 case AF_INET6:
3482 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
3483 break;
Christopher Fauletb0b76072020-09-08 10:38:40 +02003484 default:
3485 strcpy(oldip, "(none)");
3486 break;
Baptiste Assmann14e40142015-04-14 01:13:07 +02003487 };
3488
3489 /* copy new IP address in a string */
3490 switch (ip_sin_family) {
3491 case AF_INET:
3492 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
3493 break;
3494 case AF_INET6:
3495 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
3496 break;
3497 };
3498
3499 /* save log line into a buffer */
3500 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
3501 s->proxy->id, s->id, oldip, newip, updater);
3502
3503 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003504 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003505
3506 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003507 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003508 }
3509
3510 /* save the new IP family */
3511 s->addr.ss_family = ip_sin_family;
3512 /* save the new IP address */
3513 switch (ip_sin_family) {
3514 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02003515 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003516 break;
3517 case AF_INET6:
3518 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
3519 break;
3520 };
Olivier Houchard4e694042017-03-14 20:01:29 +01003521 srv_set_dyncookie(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003522
3523 return 0;
3524}
3525
3526/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003527 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3528 *
3529 * Caller can pass its name through <updater> to get it integrated in the response message
3530 * returned by the function.
3531 *
3532 * The function first does the following, in that order:
3533 * - validates the new addr and/or port
3534 * - checks if an update is required (new IP or port is different than current ones)
3535 * - checks the update is allowed:
3536 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3537 * - allow all changes if no CHECKS are configured
3538 * - if CHECK is configured:
3539 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3540 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3541 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02003542 *
3543 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003544 */
3545const char *update_server_addr_port(struct server *s, const char *addr, const char *port, char *updater)
3546{
3547 struct sockaddr_storage sa;
3548 int ret, port_change_required;
3549 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003550 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02003551 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003552 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003553
3554 msg = get_trash_chunk();
3555 chunk_reset(msg);
3556
3557 if (addr) {
3558 memset(&sa, 0, sizeof(struct sockaddr_storage));
3559 if (str2ip2(addr, &sa, 0) == NULL) {
3560 chunk_printf(msg, "Invalid addr '%s'", addr);
3561 goto out;
3562 }
3563
3564 /* changes are allowed on AF_INET* families only */
3565 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3566 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3567 goto out;
3568 }
3569
3570 /* collecting data currently setup */
3571 memset(current_addr, '\0', sizeof(current_addr));
3572 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3573 /* changes are allowed on AF_INET* families only */
3574 if ((ret != AF_INET) && (ret != AF_INET6)) {
3575 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3576 goto out;
3577 }
3578
3579 /* applying ADDR changes if required and allowed
3580 * ipcmp returns 0 when both ADDR are the same
3581 */
3582 if (ipcmp(&s->addr, &sa) == 0) {
3583 chunk_appendf(msg, "no need to change the addr");
3584 goto port;
3585 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003586 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003587 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003588
3589 /* we also need to update check's ADDR only if it uses the server's one */
3590 if ((s->check.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_CHECKADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003591 ipcpy(&sa, &s->check.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003592 }
3593
3594 /* we also need to update agent ADDR only if it use the server's one */
3595 if ((s->agent.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_AGENTADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003596 ipcpy(&sa, &s->agent.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003597 }
3598
3599 /* update report for caller */
3600 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3601 }
3602
3603 port:
3604 if (port) {
3605 char sign = '\0';
3606 char *endptr;
3607
3608 if (addr)
3609 chunk_appendf(msg, ", ");
3610
3611 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003612 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003613
3614 /* check if PORT change is required */
3615 port_change_required = 0;
3616
3617 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003618 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003619 new_port = strtol(port, &endptr, 10);
3620 if ((errno != 0) || (port == endptr)) {
3621 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3622 goto out;
3623 }
3624
3625 /* check if caller triggers a port mapped or offset */
3626 if (sign == '-' || (sign == '+')) {
3627 /* check if server currently uses port map */
3628 if (!(s->flags & SRV_F_MAPPORTS)) {
3629 /* switch from fixed port to port map mandatorily triggers
3630 * a port change */
3631 port_change_required = 1;
3632 /* check is configured
3633 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3634 * prevent PORT change if check doesn't have it's dedicated port while switching
3635 * to port mapping */
3636 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3637 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.");
3638 goto out;
3639 }
3640 }
3641 /* we're already using port maps */
3642 else {
3643 port_change_required = current_port != new_port;
3644 }
3645 }
3646 /* fixed port */
3647 else {
3648 port_change_required = current_port != new_port;
3649 }
3650
3651 /* applying PORT changes if required and update response message */
3652 if (port_change_required) {
3653 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003654 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003655 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003656
3657 /* prepare message */
3658 chunk_appendf(msg, "port changed from '");
3659 if (s->flags & SRV_F_MAPPORTS)
3660 chunk_appendf(msg, "+");
3661 chunk_appendf(msg, "%d' to '", current_port);
3662
3663 if (sign == '-') {
3664 s->flags |= SRV_F_MAPPORTS;
3665 chunk_appendf(msg, "%c", sign);
3666 /* just use for result output */
3667 new_port = -new_port;
3668 }
3669 else if (sign == '+') {
3670 s->flags |= SRV_F_MAPPORTS;
3671 chunk_appendf(msg, "%c", sign);
3672 }
3673 else {
3674 s->flags &= ~SRV_F_MAPPORTS;
3675 }
3676
3677 chunk_appendf(msg, "%d'", new_port);
3678
3679 /* we also need to update health checks port only if it uses server's realport */
3680 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3681 s->check.port = new_port;
3682 }
3683 }
3684 else {
3685 chunk_appendf(msg, "no need to change the port");
3686 }
3687 }
3688
3689out:
William Dauchy6318d332020-05-02 21:52:36 +02003690 if (changed) {
3691 /* force connection cleanup on the given server */
3692 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01003693 srv_set_dyncookie(s);
William Dauchy6318d332020-05-02 21:52:36 +02003694 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003695 if (updater)
3696 chunk_appendf(msg, " by '%s'", updater);
3697 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003698 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003699}
3700
3701
3702/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003703 * update server status based on result of name resolution
3704 * returns:
3705 * 0 if server status is updated
3706 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003707 *
3708 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003709 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003710int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003711{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003712 struct dns_resolvers *resolvers = s->resolvers;
3713 struct dns_resolution *resolution = s->dns_requester->resolution;
3714 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003715
Jerome Magnin012261a2020-07-28 13:38:22 +02003716 /* If resolution is NULL we're dealing with SRV records Additional records */
3717 if (resolution == NULL) {
Baptiste Assmann87138c32020-08-04 10:57:21 +02003718 /* since this server has an IP, it can go back in production */
3719 if (has_no_ip == 0) {
3720 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3721 return 1;
3722 }
3723
Jerome Magnin012261a2020-07-28 13:38:22 +02003724 if (s->next_admin & SRV_ADMF_RMAINT)
3725 return 1;
3726
3727 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
3728 return 0;
3729 }
3730
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003731 switch (resolution->status) {
3732 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003733 /* status when HAProxy has just (re)started.
3734 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003735 break;
3736
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003737 case RSLV_STATUS_VALID:
3738 /*
3739 * resume health checks
3740 * server will be turned back on if health check is safe
3741 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003742 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003743 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003744 return 1;
3745 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3746 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003747 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003748 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003749
Emeric Brun52a91d32017-08-31 14:41:55 +02003750 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003751 return 1;
3752 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3753 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3754 s->proxy->id, s->id);
3755
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003756 ha_warning("%s.\n", trash.area);
3757 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003758 return 0;
3759
3760 case RSLV_STATUS_NX:
3761 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003762 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3763 if (!tick_is_expired(exp, now_ms))
3764 break;
3765
3766 if (s->next_admin & SRV_ADMF_RMAINT)
3767 return 1;
3768 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3769 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003770
3771 case RSLV_STATUS_TIMEOUT:
3772 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003773 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3774 if (!tick_is_expired(exp, now_ms))
3775 break;
3776
3777 if (s->next_admin & SRV_ADMF_RMAINT)
3778 return 1;
3779 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3780 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003781
3782 case RSLV_STATUS_REFUSED:
3783 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003784 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3785 if (!tick_is_expired(exp, now_ms))
3786 break;
3787
3788 if (s->next_admin & SRV_ADMF_RMAINT)
3789 return 1;
3790 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3791 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003792
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003793 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003794 /* stop server if resolution failed for a long enough period */
3795 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3796 if (!tick_is_expired(exp, now_ms))
3797 break;
3798
3799 if (s->next_admin & SRV_ADMF_RMAINT)
3800 return 1;
3801 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3802 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003803 }
3804
3805 return 1;
3806}
3807
3808/*
3809 * Server Name Resolution valid response callback
3810 * It expects:
3811 * - <nameserver>: the name server which answered the valid response
3812 * - <response>: buffer containing a valid DNS response
3813 * - <response_len>: size of <response>
3814 * It performs the following actions:
3815 * - ignore response if current ip found and server family not met
3816 * - update with first new ip found if family is met and current IP is not found
3817 * returns:
3818 * 0 on error
3819 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003820 *
3821 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003822 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003823int snr_resolution_cb(struct dns_requester *requester, struct dns_nameserver *nameserver)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003824{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003825 struct server *s = NULL;
3826 struct dns_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003827 void *serverip, *firstip;
3828 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003829 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003830 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003831 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003832
Christopher Faulet67957bd2017-09-27 11:00:59 +02003833 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003834 if (!s)
3835 return 1;
3836
Christopher Faulet67957bd2017-09-27 11:00:59 +02003837 resolution = s->dns_requester->resolution;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003838
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003839 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003840 firstip = NULL; /* pointer to the first valid response found */
3841 /* it will be used as the new IP if a change is required */
3842 firstip_sin_family = AF_UNSPEC;
3843 serverip = NULL; /* current server IP address */
3844
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003845 /* initializing server IP pointer */
3846 server_sin_family = s->addr.ss_family;
3847 switch (server_sin_family) {
3848 case AF_INET:
3849 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3850 break;
3851
3852 case AF_INET6:
3853 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3854 break;
3855
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003856 case AF_UNSPEC:
3857 break;
3858
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003859 default:
3860 goto invalid;
3861 }
3862
Baptiste Assmann729c9012017-05-22 15:13:10 +02003863 ret = dns_get_ip_from_response(&resolution->response, &s->dns_opts,
Thierry Fournierada34842016-02-17 21:25:09 +01003864 serverip, server_sin_family, &firstip,
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003865 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003866
3867 switch (ret) {
3868 case DNS_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003869 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003870
3871 case DNS_UPD_SRVIP_NOT_FOUND:
3872 goto save_ip;
3873
3874 case DNS_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003875 goto invalid;
3876
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003877 case DNS_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003878 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003879 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003880
Baptiste Assmannfad03182015-10-28 02:03:32 +01003881 case DNS_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003882 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003883 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003884 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003885
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003886 default:
3887 goto invalid;
3888
3889 }
3890
3891 save_ip:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003892 if (nameserver) {
Amaury Denoyellefbd0bc92020-10-05 11:49:46 +02003893 nameserver->counters->update++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003894 /* save the first ip we found */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003895 chunk_printf(chk, "%s/%s", nameserver->resolvers->id, nameserver->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003896 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003897 else
3898 chunk_printf(chk, "DNS cache");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003899 update_server_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003900
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003901 update_status:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003902 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003903 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003904
3905 invalid:
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003906 if (nameserver) {
Amaury Denoyellefbd0bc92020-10-05 11:49:46 +02003907 nameserver->counters->invalid++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003908 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003909 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003910 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003911 return 0;
3912}
3913
3914/*
3915 * Server Name Resolution error management callback
3916 * returns:
3917 * 0 on error
3918 * 1 when no error or safe ignore
Willy Tarreau46b7f532018-08-21 11:54:26 +02003919 *
3920 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003921 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003922int snr_resolution_error_cb(struct dns_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003923{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003924 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003925
Christopher Faulet67957bd2017-09-27 11:00:59 +02003926 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003927 if (!s)
3928 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003929 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003930 snr_update_srv_status(s, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003931 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003932 return 1;
3933}
3934
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003935/*
3936 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003937 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003938 * It returns a pointer to the first server found or NULL if <ip> is not yet
3939 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003940 *
3941 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003942 */
3943struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3944{
3945 struct server *tmpsrv;
3946 struct proxy *be;
3947
3948 if (!srv)
3949 return NULL;
3950
3951 be = srv->proxy;
3952 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003953 /* we found the current server is the same, ignore it */
3954 if (srv == tmpsrv)
3955 continue;
3956
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003957 /* We want to compare the IP in the record with the IP of the servers in the
3958 * same backend, only if:
3959 * * DNS resolution is enabled on the server
3960 * * the hostname used for the resolution by our server is the same than the
3961 * one used for the server found in the backend
3962 * * the server found in the backend is not our current server
3963 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003964 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003965 if ((tmpsrv->hostname_dn == NULL) ||
3966 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
3967 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01003968 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003969 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003970 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003971 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003972
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003973 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01003974 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003975 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003976 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003977 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003978
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003979 /* At this point, we have 2 different servers using the same DNS hostname
3980 * for their respective resolution.
3981 */
3982 if (*ip_family == tmpsrv->addr.ss_family &&
3983 ((tmpsrv->addr.ss_family == AF_INET &&
3984 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3985 (tmpsrv->addr.ss_family == AF_INET6 &&
3986 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003987 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003988 return tmpsrv;
3989 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003990 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003991 }
3992
Emeric Brune9fd6b52017-11-02 17:20:39 +01003993
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003994 return NULL;
3995}
3996
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003997/* Sets the server's address (srv->addr) from srv->hostname using the libc's
3998 * resolver. This is suited for initial address configuration. Returns 0 on
3999 * success otherwise a non-zero error code. In case of error, *err_code, if
4000 * not NULL, is filled up.
4001 */
4002int srv_set_addr_via_libc(struct server *srv, int *err_code)
4003{
4004 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004005 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01004006 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004007 return 1;
4008 }
4009 return 0;
4010}
4011
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004012/* Set the server's FDQN (->hostname) from <hostname>.
4013 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004014 *
4015 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004016 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004017int srv_set_fqdn(struct server *srv, const char *hostname, int dns_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004018{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004019 struct dns_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004020 char *hostname_dn;
4021 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004022
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02004023 /* Note that the server lock is already held. */
4024 if (!srv->resolvers)
4025 return -1;
4026
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004027 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004028 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004029 /* run time DNS resolution was not active for this server
4030 * and we can't enable it at run time for now.
4031 */
4032 if (!srv->dns_requester)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004033 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004034
4035 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004036 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004037 hostname_dn = trash.area;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004038 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
4039 hostname_dn, trash.size);
4040 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004041 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004042
Christopher Faulet67957bd2017-09-27 11:00:59 +02004043 resolution = srv->dns_requester->resolution;
4044 if (resolution &&
4045 resolution->hostname_dn &&
4046 !strcmp(resolution->hostname_dn, hostname_dn))
Christopher Fauletb2812a62017-10-04 16:17:58 +02004047 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004048
Christopher Faulet67957bd2017-09-27 11:00:59 +02004049 dns_unlink_resolution(srv->dns_requester);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004050
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004051 free(srv->hostname);
4052 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004053 srv->hostname = strdup(hostname);
4054 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004055 srv->hostname_dn_len = hostname_dn_len;
4056 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004057 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004058
Baptiste Assmann13a92322019-06-07 09:40:55 +02004059 if (srv->flags & SRV_F_NO_RESOLUTION)
4060 goto end;
4061
Olivier Houchard55dcdf42017-11-06 15:15:04 +01004062 if (dns_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004063 goto err;
4064
4065 end:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004066 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004067 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004068 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02004069
4070 err:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004071 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004072 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02004073 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004074}
4075
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004076/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
4077 * from the state file. This is suited for initial address configuration.
4078 * Returns 0 on success otherwise a non-zero error code. In case of error,
4079 * *err_code, if not NULL, is filled up.
4080 */
4081static int srv_apply_lastaddr(struct server *srv, int *err_code)
4082{
4083 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
4084 if (err_code)
4085 *err_code |= ERR_WARN;
4086 return 1;
4087 }
4088 return 0;
4089}
4090
Willy Tarreau25e51522016-11-04 15:10:17 +01004091/* returns 0 if no error, otherwise a combination of ERR_* flags */
4092static int srv_iterate_initaddr(struct server *srv)
4093{
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004094 char *name = srv->hostname;
Willy Tarreau25e51522016-11-04 15:10:17 +01004095 int return_code = 0;
4096 int err_code;
4097 unsigned int methods;
4098
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004099 /* If no addr and no hostname set, get the name from the DNS SRV request */
4100 if (!name && srv->srvrq)
4101 name = srv->srvrq->name;
4102
Willy Tarreau25e51522016-11-04 15:10:17 +01004103 methods = srv->init_addr_methods;
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004104 if (!methods) {
4105 /* otherwise default to "last,libc" */
Willy Tarreau25e51522016-11-04 15:10:17 +01004106 srv_append_initaddr(&methods, SRV_IADDR_LAST);
4107 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004108 if (srv->resolvers_id) {
4109 /* dns resolution is configured, add "none" to not fail on startup */
4110 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4111 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004112 }
4113
Willy Tarreau3eed10e2016-11-07 21:03:16 +01004114 /* "-dr" : always append "none" so that server addresses resolution
4115 * failures are silently ignored, this is convenient to validate some
4116 * configs out of their environment.
4117 */
4118 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
4119 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4120
Willy Tarreau25e51522016-11-04 15:10:17 +01004121 while (methods) {
4122 err_code = 0;
4123 switch (srv_get_next_initaddr(&methods)) {
4124 case SRV_IADDR_LAST:
4125 if (!srv->lastaddr)
4126 continue;
4127 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004128 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004129 return_code |= err_code;
4130 break;
4131
4132 case SRV_IADDR_LIBC:
4133 if (!srv->hostname)
4134 continue;
4135 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004136 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004137 return_code |= err_code;
4138 break;
4139
Willy Tarreau37ebe122016-11-04 15:17:58 +01004140 case SRV_IADDR_NONE:
4141 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004142 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004143 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004144 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004145 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01004146 return return_code;
4147
Willy Tarreau4310d362016-11-02 15:05:56 +01004148 case SRV_IADDR_IP:
4149 ipcpy(&srv->init_addr, &srv->addr);
4150 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004151 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 +01004152 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau4310d362016-11-02 15:05:56 +01004153 }
Olivier Houchard4e694042017-03-14 20:01:29 +01004154 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01004155
Willy Tarreau25e51522016-11-04 15:10:17 +01004156 default: /* unhandled method */
4157 break;
4158 }
4159 }
4160
4161 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004162 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004163 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau25e51522016-11-04 15:10:17 +01004164 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01004165 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004166 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004167 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004168 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004169
4170 return_code |= ERR_ALERT | ERR_FATAL;
4171 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01004172out:
4173 srv_set_dyncookie(srv);
4174 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01004175}
4176
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004177/*
4178 * This function parses all backends and all servers within each backend
4179 * and performs servers' addr resolution based on information provided by:
4180 * - configuration file
4181 * - server-state file (states provided by an 'old' haproxy process)
4182 *
4183 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
4184 */
4185int srv_init_addr(void)
4186{
4187 struct proxy *curproxy;
4188 int return_code = 0;
4189
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004190 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004191 while (curproxy) {
4192 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004193
4194 /* servers are in backend only */
4195 if (!(curproxy->cap & PR_CAP_BE))
4196 goto srv_init_addr_next;
4197
Willy Tarreau25e51522016-11-04 15:10:17 +01004198 for (srv = curproxy->srv; srv; srv = srv->next)
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01004199 if (srv->hostname || srv->srvrq)
Willy Tarreau3d609a72017-09-06 14:22:45 +02004200 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004201
4202 srv_init_addr_next:
4203 curproxy = curproxy->next;
4204 }
4205
4206 return return_code;
4207}
4208
Willy Tarreau46b7f532018-08-21 11:54:26 +02004209/*
4210 * Must be called with the server lock held.
4211 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004212const char *update_server_fqdn(struct server *server, const char *fqdn, const char *updater, int dns_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004213{
4214
Willy Tarreau83061a82018-07-13 11:56:34 +02004215 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004216
4217 msg = get_trash_chunk();
4218 chunk_reset(msg);
4219
Olivier Houchard8da5f982017-08-04 18:35:36 +02004220 if (server->hostname && !strcmp(fqdn, server->hostname)) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004221 chunk_appendf(msg, "no need to change the FDQN");
4222 goto out;
4223 }
4224
4225 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
4226 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
4227 goto out;
4228 }
4229
4230 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
4231 server->proxy->id, server->id, server->hostname, fqdn);
4232
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004233 if (srv_set_fqdn(server, fqdn, dns_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004234 chunk_reset(msg);
4235 chunk_appendf(msg, "could not update %s/%s FQDN",
4236 server->proxy->id, server->id);
4237 goto out;
4238 }
4239
4240 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02004241 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004242
4243 out:
4244 if (updater)
4245 chunk_appendf(msg, " by '%s'", updater);
4246 chunk_appendf(msg, "\n");
4247
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004248 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004249}
4250
4251
Willy Tarreau21b069d2016-11-23 17:15:08 +01004252/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
4253 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004254 * 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 +01004255 * used for CLI commands requiring a server name.
4256 * Important: the <arg> is modified to remove the '/'.
4257 */
4258struct server *cli_find_server(struct appctx *appctx, char *arg)
4259{
4260 struct proxy *px;
4261 struct server *sv;
4262 char *line;
4263
4264 /* split "backend/server" and make <line> point to server */
4265 for (line = arg; *line; line++)
4266 if (*line == '/') {
4267 *line++ = '\0';
4268 break;
4269 }
4270
4271 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004272 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004273 return NULL;
4274 }
4275
4276 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004277 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004278 return NULL;
4279 }
4280
Willy Tarreauc3914d42020-09-24 08:39:22 +02004281 if (px->disabled) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004282 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004283 return NULL;
4284 }
4285
4286 return sv;
4287}
4288
William Lallemand222baf22016-11-19 02:00:33 +01004289
Willy Tarreau46b7f532018-08-21 11:54:26 +02004290/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004291static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01004292{
4293 struct server *sv;
4294 const char *warning;
4295
4296 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4297 return 1;
4298
4299 sv = cli_find_server(appctx, args[2]);
4300 if (!sv)
4301 return 1;
4302
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004303 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02004304
William Lallemand222baf22016-11-19 02:00:33 +01004305 if (strcmp(args[3], "weight") == 0) {
4306 warning = server_parse_weight_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004307 if (warning)
4308 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004309 }
4310 else if (strcmp(args[3], "state") == 0) {
4311 if (strcmp(args[4], "ready") == 0)
4312 srv_adm_set_ready(sv);
4313 else if (strcmp(args[4], "drain") == 0)
4314 srv_adm_set_drain(sv);
4315 else if (strcmp(args[4], "maint") == 0)
4316 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02004317 else
4318 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004319 }
4320 else if (strcmp(args[3], "health") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004321 if (sv->track)
4322 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004323 else if (strcmp(args[4], "up") == 0) {
4324 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004325 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004326 }
4327 else if (strcmp(args[4], "stopping") == 0) {
4328 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004329 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004330 }
4331 else if (strcmp(args[4], "down") == 0) {
4332 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004333 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004334 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004335 else
4336 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004337 }
4338 else if (strcmp(args[3], "agent") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004339 if (!(sv->agent.state & CHK_ST_ENABLED))
4340 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004341 else if (strcmp(args[4], "up") == 0) {
4342 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004343 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004344 }
4345 else if (strcmp(args[4], "down") == 0) {
4346 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004347 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004348 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004349 else
4350 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004351 }
Misiek2da082d2017-01-09 09:40:42 +01004352 else if (strcmp(args[3], "agent-addr") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004353 if (!(sv->agent.state & CHK_ST_ENABLED))
4354 cli_err(appctx, "agent checks are not enabled on this server.\n");
4355 else if (str2ip(args[4], &sv->agent.addr) == NULL)
4356 cli_err(appctx, "incorrect addr address given for agent.\n");
Misiek2da082d2017-01-09 09:40:42 +01004357 }
4358 else if (strcmp(args[3], "agent-send") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004359 if (!(sv->agent.state & CHK_ST_ENABLED))
4360 cli_err(appctx, "agent checks are not enabled on this server.\n");
4361 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02004362 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02004363 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01004364 }
4365 }
William Lallemand222baf22016-11-19 02:00:33 +01004366 else if (strcmp(args[3], "check-port") == 0) {
4367 int i = 0;
4368 if (strl2irc(args[4], strlen(args[4]), &i) != 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004369 cli_err(appctx, "'set server <srv> check-port' expects an integer as argument.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004370 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004371 }
4372 if ((i < 0) || (i > 65535)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004373 cli_err(appctx, "provided port is not valid.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004374 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004375 }
4376 /* prevent the update of port to 0 if MAPPORTS are in use */
4377 if ((sv->flags & SRV_F_MAPPORTS) && (i == 0)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004378 cli_err(appctx, "can't unset 'port' since MAPPORTS is in use.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004379 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004380 }
4381 sv->check.port = i;
Willy Tarreau9d008692019-08-09 11:21:01 +02004382 cli_msg(appctx, LOG_NOTICE, "health check port updated.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004383 }
4384 else if (strcmp(args[3], "addr") == 0) {
4385 char *addr = NULL;
4386 char *port = NULL;
4387 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004388 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004389 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004390 }
4391 else {
4392 addr = args[4];
4393 }
4394 if (strcmp(args[5], "port") == 0) {
4395 port = args[6];
4396 }
4397 warning = update_server_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02004398 if (warning)
4399 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004400 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
4401 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004402 else if (strcmp(args[3], "fqdn") == 0) {
4403 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004404 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004405 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004406 }
Baptiste Assmann13a92322019-06-07 09:40:55 +02004407 /* ensure runtime resolver will process this new fqdn */
4408 if (sv->flags & SRV_F_NO_RESOLUTION) {
4409 sv->flags &= ~SRV_F_NO_RESOLUTION;
4410 }
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004411 warning = update_server_fqdn(sv, args[4], "stats socket command", 0);
Willy Tarreau9d008692019-08-09 11:21:01 +02004412 if (warning)
4413 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004414 }
William Dauchyf6370442020-11-14 19:25:33 +01004415 else if (strcmp(args[3], "ssl") == 0) {
4416#ifdef USE_OPENSSL
4417 if (sv->ssl_ctx.ctx == NULL) {
4418 cli_err(appctx, "'set server <srv> ssl' cannot be set. "
4419 " default-server should define ssl settings\n");
4420 goto out_unlock;
4421 } else if (strcmp(args[4], "on") == 0) {
4422 ssl_sock_set_srv(sv, 1);
4423 } else if (strcmp(args[4], "off") == 0) {
4424 ssl_sock_set_srv(sv, 0);
4425 } else {
4426 cli_err(appctx, "'set server <srv> ssl' expects 'on' or 'off'.\n");
4427 goto out_unlock;
4428 }
4429 srv_cleanup_connections(sv);
4430 cli_msg(appctx, LOG_NOTICE, "server ssl setting updated.\n");
4431#else
4432 cli_msg(appctx, LOG_NOTICE, "server ssl setting not supported.\n");
4433#endif
4434 } else {
Willy Tarreau9d008692019-08-09 11:21:01 +02004435 cli_err(appctx,
4436 "'set server <srv>' only supports 'agent', 'health', 'state',"
William Dauchyf6370442020-11-14 19:25:33 +01004437 " 'weight', 'addr', 'fqdn', 'check-port' and 'ssl'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004438 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004439 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004440 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004441 return 1;
4442}
4443
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004444static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004445{
4446 struct stream_interface *si = appctx->owner;
4447 struct proxy *px;
4448 struct server *sv;
4449 char *line;
4450
4451
4452 /* split "backend/server" and make <line> point to server */
4453 for (line = args[2]; *line; line++)
4454 if (*line == '/') {
4455 *line++ = '\0';
4456 break;
4457 }
4458
Willy Tarreau9d008692019-08-09 11:21:01 +02004459 if (!*line)
4460 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004461
Willy Tarreau9d008692019-08-09 11:21:01 +02004462 if (!get_backend_server(args[2], line, &px, &sv))
4463 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004464
4465 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004466 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
4467 sv->iweight);
4468 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004469 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004470 return 0;
4471 }
William Lallemand6b160942016-11-22 12:34:35 +01004472 return 1;
4473}
4474
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004475/* Parse a "set weight" command.
4476 *
4477 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004478 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004479static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004480{
4481 struct server *sv;
4482 const char *warning;
4483
4484 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4485 return 1;
4486
4487 sv = cli_find_server(appctx, args[2]);
4488 if (!sv)
4489 return 1;
4490
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004491 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4492
William Lallemand6b160942016-11-22 12:34:35 +01004493 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004494 if (warning)
4495 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004496
4497 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4498
William Lallemand6b160942016-11-22 12:34:35 +01004499 return 1;
4500}
4501
Willy Tarreau46b7f532018-08-21 11:54:26 +02004502/* parse a "set maxconn server" command. It always returns 1.
4503 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004504 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004505 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004506static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01004507{
4508 struct server *sv;
4509 const char *warning;
4510
4511 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4512 return 1;
4513
4514 sv = cli_find_server(appctx, args[3]);
4515 if (!sv)
4516 return 1;
4517
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004518 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4519
Willy Tarreaub8026272016-11-23 11:26:56 +01004520 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004521 if (warning)
4522 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004523
4524 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4525
Willy Tarreaub8026272016-11-23 11:26:56 +01004526 return 1;
4527}
William Lallemand6b160942016-11-22 12:34:35 +01004528
Willy Tarreau46b7f532018-08-21 11:54:26 +02004529/* parse a "disable agent" command. It always returns 1.
4530 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004531 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004532 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004533static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004534{
4535 struct server *sv;
4536
4537 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4538 return 1;
4539
4540 sv = cli_find_server(appctx, args[2]);
4541 if (!sv)
4542 return 1;
4543
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004544 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004545 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004546 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004547 return 1;
4548}
4549
Willy Tarreau46b7f532018-08-21 11:54:26 +02004550/* parse a "disable health" command. It always returns 1.
4551 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004552 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004553 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004554static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004555{
4556 struct server *sv;
4557
4558 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4559 return 1;
4560
4561 sv = cli_find_server(appctx, args[2]);
4562 if (!sv)
4563 return 1;
4564
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004565 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004566 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004567 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004568 return 1;
4569}
4570
Willy Tarreau46b7f532018-08-21 11:54:26 +02004571/* parse a "disable server" command. It always returns 1.
4572 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004573 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004574 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004575static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004576{
4577 struct server *sv;
4578
4579 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4580 return 1;
4581
4582 sv = cli_find_server(appctx, args[2]);
4583 if (!sv)
4584 return 1;
4585
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004586 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004587 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004588 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004589 return 1;
4590}
4591
Willy Tarreau46b7f532018-08-21 11:54:26 +02004592/* parse a "enable agent" command. It always returns 1.
4593 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004594 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004595 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004596static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004597{
4598 struct server *sv;
4599
4600 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4601 return 1;
4602
4603 sv = cli_find_server(appctx, args[2]);
4604 if (!sv)
4605 return 1;
4606
Willy Tarreau9d008692019-08-09 11:21:01 +02004607 if (!(sv->agent.state & CHK_ST_CONFIGURED))
4608 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004609
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004610 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004611 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004612 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004613 return 1;
4614}
4615
Willy Tarreau46b7f532018-08-21 11:54:26 +02004616/* parse a "enable health" command. It always returns 1.
4617 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004618 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004619 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004620static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004621{
4622 struct server *sv;
4623
4624 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4625 return 1;
4626
4627 sv = cli_find_server(appctx, args[2]);
4628 if (!sv)
4629 return 1;
4630
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004631 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004632 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004633 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004634 return 1;
4635}
4636
Willy Tarreau46b7f532018-08-21 11:54:26 +02004637/* parse a "enable server" command. It always returns 1.
4638 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004639 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004640 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004641static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004642{
4643 struct server *sv;
4644
4645 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4646 return 1;
4647
4648 sv = cli_find_server(appctx, args[2]);
4649 if (!sv)
4650 return 1;
4651
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004652 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004653 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004654 if (!(sv->flags & SRV_F_COOKIESET)
4655 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4656 sv->cookie)
4657 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004658 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004659 return 1;
4660}
4661
William Lallemand222baf22016-11-19 02:00:33 +01004662/* register cli keywords */
4663static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004664 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004665 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004666 { { "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 +01004667 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004668 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004669 { { "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 +01004670 { { "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 +01004671 { { "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 +01004672 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4673 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4674
William Lallemand222baf22016-11-19 02:00:33 +01004675 {{},}
4676}};
4677
Willy Tarreau0108d902018-11-25 19:14:37 +01004678INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004679
Emeric Brun64cc49c2017-10-03 14:46:45 +02004680/*
4681 * This function applies server's status changes, it is
4682 * is designed to be called asynchronously.
4683 *
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004684 * Must be called with the server lock held. This may also be called at init
4685 * time as the result of parsing the state file, in which case no lock will be
4686 * held, and the server's warmup task can be null.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004687 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004688static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004689{
4690 struct check *check = &s->check;
4691 int xferred;
4692 struct proxy *px = s->proxy;
4693 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4694 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4695 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004696 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004697
Emeric Brun64cc49c2017-10-03 14:46:45 +02004698 /* If currently main is not set we try to apply pending state changes */
4699 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4700 int next_admin;
4701
4702 /* Backup next admin */
4703 next_admin = s->next_admin;
4704
4705 /* restore current admin state */
4706 s->next_admin = s->cur_admin;
4707
4708 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4709 s->last_change = now.tv_sec;
4710 if (s->proxy->lbprm.set_server_status_down)
4711 s->proxy->lbprm.set_server_status_down(s);
4712
4713 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4714 srv_shutdown_streams(s, SF_ERR_DOWN);
4715
4716 /* we might have streams queued on this server and waiting for
4717 * a connection. Those which are redispatchable will be queued
4718 * to another server or to the proxy itself.
4719 */
4720 xferred = pendconn_redistribute(s);
4721
4722 tmptrash = alloc_trash_chunk();
4723 if (tmptrash) {
4724 chunk_printf(tmptrash,
4725 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4726 s->proxy->id, s->id);
4727
Emeric Brun5a133512017-10-19 14:42:30 +02004728 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004729 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004730
4731 /* we don't send an alert if the server was previously paused */
4732 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004733 send_log(s->proxy, log_level, "%s.\n",
4734 tmptrash->area);
4735 send_email_alert(s, log_level, "%s",
4736 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004737 free_trash_chunk(tmptrash);
4738 tmptrash = NULL;
4739 }
4740 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4741 set_backend_down(s->proxy);
4742
4743 s->counters.down_trans++;
4744 }
4745 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4746 s->last_change = now.tv_sec;
4747 if (s->proxy->lbprm.set_server_status_down)
4748 s->proxy->lbprm.set_server_status_down(s);
4749
4750 /* we might have streams queued on this server and waiting for
4751 * a connection. Those which are redispatchable will be queued
4752 * to another server or to the proxy itself.
4753 */
4754 xferred = pendconn_redistribute(s);
4755
4756 tmptrash = alloc_trash_chunk();
4757 if (tmptrash) {
4758 chunk_printf(tmptrash,
4759 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4760 s->proxy->id, s->id);
4761
Emeric Brun5a133512017-10-19 14:42:30 +02004762 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004763
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004764 ha_warning("%s.\n", tmptrash->area);
4765 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4766 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004767 free_trash_chunk(tmptrash);
4768 tmptrash = NULL;
4769 }
4770
4771 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4772 set_backend_down(s->proxy);
4773 }
4774 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4775 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4776 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4777 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4778 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4779 s->proxy->last_change = now.tv_sec;
4780 }
4781
Amaury Denoyellefe2bf092020-10-29 15:59:04 +01004782 if (s->cur_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
Emeric Brun64cc49c2017-10-03 14:46:45 +02004783 s->down_time += now.tv_sec - s->last_change;
4784
4785 s->last_change = now.tv_sec;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004786 if (s->next_state == SRV_ST_STARTING && s->warmup)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004787 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4788
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004789 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004790 /* now propagate the status change to any LB algorithms */
4791 if (px->lbprm.update_server_eweight)
4792 px->lbprm.update_server_eweight(s);
4793 else if (srv_willbe_usable(s)) {
4794 if (px->lbprm.set_server_status_up)
4795 px->lbprm.set_server_status_up(s);
4796 }
4797 else {
4798 if (px->lbprm.set_server_status_down)
4799 px->lbprm.set_server_status_down(s);
4800 }
4801
4802 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4803 * and it's not a backup server and its effective weight is > 0,
4804 * then it can accept new connections, so we shut down all streams
4805 * on all backup servers.
4806 */
4807 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4808 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4809 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4810
4811 /* check if we can handle some connections queued at the proxy. We
4812 * will take as many as we can handle.
4813 */
4814 xferred = pendconn_grab_from_px(s);
4815
4816 tmptrash = alloc_trash_chunk();
4817 if (tmptrash) {
4818 chunk_printf(tmptrash,
4819 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4820 s->proxy->id, s->id);
4821
Emeric Brun5a133512017-10-19 14:42:30 +02004822 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004823 ha_warning("%s.\n", tmptrash->area);
4824 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4825 tmptrash->area);
4826 send_email_alert(s, LOG_NOTICE, "%s",
4827 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004828 free_trash_chunk(tmptrash);
4829 tmptrash = NULL;
4830 }
4831
4832 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4833 set_backend_down(s->proxy);
4834 }
4835 else if (s->cur_eweight != s->next_eweight) {
4836 /* now propagate the status change to any LB algorithms */
4837 if (px->lbprm.update_server_eweight)
4838 px->lbprm.update_server_eweight(s);
4839 else if (srv_willbe_usable(s)) {
4840 if (px->lbprm.set_server_status_up)
4841 px->lbprm.set_server_status_up(s);
4842 }
4843 else {
4844 if (px->lbprm.set_server_status_down)
4845 px->lbprm.set_server_status_down(s);
4846 }
4847
4848 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4849 set_backend_down(s->proxy);
4850 }
4851
4852 s->next_admin = next_admin;
4853 }
4854
Emeric Brun5a133512017-10-19 14:42:30 +02004855 /* reset operational state change */
4856 *s->op_st_chg.reason = 0;
4857 s->op_st_chg.status = s->op_st_chg.code = -1;
4858 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004859
4860 /* Now we try to apply pending admin changes */
4861
4862 /* Maintenance must also disable health checks */
4863 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4864 if (s->check.state & CHK_ST_ENABLED) {
4865 s->check.state |= CHK_ST_PAUSED;
4866 check->health = 0;
4867 }
4868
4869 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004870 tmptrash = alloc_trash_chunk();
4871 if (tmptrash) {
4872 chunk_printf(tmptrash,
4873 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4874 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4875 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004876
Olivier Houchard796a2b32017-10-24 17:42:47 +02004877 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004878
Olivier Houchard796a2b32017-10-24 17:42:47 +02004879 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004880 ha_warning("%s.\n", tmptrash->area);
4881 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4882 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004883 }
4884 free_trash_chunk(tmptrash);
4885 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004886 }
Emeric Brun8f298292017-12-06 16:47:17 +01004887 /* commit new admin status */
4888
4889 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004890 }
4891 else { /* server was still running */
4892 check->health = 0; /* failure */
4893 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004894
4895 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004896 if (s->proxy->lbprm.set_server_status_down)
4897 s->proxy->lbprm.set_server_status_down(s);
4898
Emeric Brun64cc49c2017-10-03 14:46:45 +02004899 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4900 srv_shutdown_streams(s, SF_ERR_DOWN);
4901
William Dauchy6318d332020-05-02 21:52:36 +02004902 /* force connection cleanup on the given server */
4903 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004904 /* we might have streams queued on this server and waiting for
4905 * a connection. Those which are redispatchable will be queued
4906 * to another server or to the proxy itself.
4907 */
4908 xferred = pendconn_redistribute(s);
4909
4910 tmptrash = alloc_trash_chunk();
4911 if (tmptrash) {
4912 chunk_printf(tmptrash,
4913 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
4914 s->flags & SRV_F_BACKUP ? "Backup " : "",
4915 s->proxy->id, s->id,
4916 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4917
4918 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
4919
4920 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004921 ha_warning("%s.\n", tmptrash->area);
4922 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
4923 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004924 }
4925 free_trash_chunk(tmptrash);
4926 tmptrash = NULL;
4927 }
4928 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4929 set_backend_down(s->proxy);
4930
4931 s->counters.down_trans++;
4932 }
4933 }
4934 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
4935 /* OK here we're leaving maintenance, we have many things to check,
4936 * because the server might possibly be coming back up depending on
4937 * its state. In practice, leaving maintenance means that we should
4938 * immediately turn to UP (more or less the slowstart) under the
4939 * following conditions :
4940 * - server is neither checked nor tracked
4941 * - server tracks another server which is not checked
4942 * - server tracks another server which is already up
4943 * Which sums up as something simpler :
4944 * "either the tracking server is up or the server's checks are disabled
4945 * or up". Otherwise we only re-enable health checks. There's a special
4946 * case associated to the stopping state which can be inherited. Note
4947 * that the server might still be in drain mode, which is naturally dealt
4948 * with by the lower level functions.
4949 */
4950
4951 if (s->check.state & CHK_ST_ENABLED) {
4952 s->check.state &= ~CHK_ST_PAUSED;
4953 check->health = check->rise; /* start OK but check immediately */
4954 }
4955
4956 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
4957 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
4958 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
4959 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
4960 s->next_state = SRV_ST_STOPPING;
4961 }
4962 else {
4963 s->next_state = SRV_ST_STARTING;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004964 if (s->slowstart > 0) {
4965 if (s->warmup)
4966 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4967 }
Emeric Brun64cc49c2017-10-03 14:46:45 +02004968 else
4969 s->next_state = SRV_ST_RUNNING;
4970 }
4971
4972 }
4973
4974 tmptrash = alloc_trash_chunk();
4975 if (tmptrash) {
4976 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4977 chunk_printf(tmptrash,
4978 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
4979 s->flags & SRV_F_BACKUP ? "Backup " : "",
4980 s->proxy->id, s->id,
4981 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4982 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4983 }
4984 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4985 chunk_printf(tmptrash,
4986 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
4987 s->flags & SRV_F_BACKUP ? "Backup " : "",
4988 s->proxy->id, s->id, s->hostname,
4989 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4990 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4991 }
4992 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4993 chunk_printf(tmptrash,
4994 "%sServer %s/%s is %s/%s (leaving maintenance)",
4995 s->flags & SRV_F_BACKUP ? "Backup " : "",
4996 s->proxy->id, s->id,
4997 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4998 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4999 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005000 ha_warning("%s.\n", tmptrash->area);
5001 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5002 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005003 free_trash_chunk(tmptrash);
5004 tmptrash = NULL;
5005 }
5006
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005007 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005008 /* now propagate the status change to any LB algorithms */
5009 if (px->lbprm.update_server_eweight)
5010 px->lbprm.update_server_eweight(s);
5011 else if (srv_willbe_usable(s)) {
5012 if (px->lbprm.set_server_status_up)
5013 px->lbprm.set_server_status_up(s);
5014 }
5015 else {
5016 if (px->lbprm.set_server_status_down)
5017 px->lbprm.set_server_status_down(s);
5018 }
5019
5020 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5021 set_backend_down(s->proxy);
5022
Willy Tarreau6a78e612018-08-07 10:14:53 +02005023 /* If the server is set with "on-marked-up shutdown-backup-sessions",
5024 * and it's not a backup server and its effective weight is > 0,
5025 * then it can accept new connections, so we shut down all streams
5026 * on all backup servers.
5027 */
5028 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
5029 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
5030 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
5031
5032 /* check if we can handle some connections queued at the proxy. We
5033 * will take as many as we can handle.
5034 */
5035 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005036 }
5037 else if (s->next_admin & SRV_ADMF_MAINT) {
5038 /* remaining in maintenance mode, let's inform precisely about the
5039 * situation.
5040 */
5041 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5042 tmptrash = alloc_trash_chunk();
5043 if (tmptrash) {
5044 chunk_printf(tmptrash,
5045 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
5046 s->flags & SRV_F_BACKUP ? "Backup " : "",
5047 s->proxy->id, s->id);
5048
5049 if (s->track) /* normally it's mandatory here */
5050 chunk_appendf(tmptrash, " via %s/%s",
5051 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005052 ha_warning("%s.\n", tmptrash->area);
5053 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5054 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005055 free_trash_chunk(tmptrash);
5056 tmptrash = NULL;
5057 }
5058 }
5059 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5060 tmptrash = alloc_trash_chunk();
5061 if (tmptrash) {
5062 chunk_printf(tmptrash,
5063 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
5064 s->flags & SRV_F_BACKUP ? "Backup " : "",
5065 s->proxy->id, s->id, s->hostname);
5066
5067 if (s->track) /* normally it's mandatory here */
5068 chunk_appendf(tmptrash, " via %s/%s",
5069 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005070 ha_warning("%s.\n", tmptrash->area);
5071 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5072 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005073 free_trash_chunk(tmptrash);
5074 tmptrash = NULL;
5075 }
5076 }
5077 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5078 tmptrash = alloc_trash_chunk();
5079 if (tmptrash) {
5080 chunk_printf(tmptrash,
5081 "%sServer %s/%s remains in forced maintenance",
5082 s->flags & SRV_F_BACKUP ? "Backup " : "",
5083 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005084 ha_warning("%s.\n", tmptrash->area);
5085 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5086 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005087 free_trash_chunk(tmptrash);
5088 tmptrash = NULL;
5089 }
5090 }
5091 /* don't report anything when leaving drain mode and remaining in maintenance */
5092
5093 s->cur_admin = s->next_admin;
5094 }
5095
5096 if (!(s->next_admin & SRV_ADMF_MAINT)) {
5097 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
5098 /* drain state is applied only if not yet in maint */
5099
5100 s->last_change = now.tv_sec;
5101 if (px->lbprm.set_server_status_down)
5102 px->lbprm.set_server_status_down(s);
5103
5104 /* we might have streams queued on this server and waiting for
5105 * a connection. Those which are redispatchable will be queued
5106 * to another server or to the proxy itself.
5107 */
5108 xferred = pendconn_redistribute(s);
5109
5110 tmptrash = alloc_trash_chunk();
5111 if (tmptrash) {
5112 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
5113 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5114 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5115
5116 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
5117
5118 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005119 ha_warning("%s.\n", tmptrash->area);
5120 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5121 tmptrash->area);
5122 send_email_alert(s, LOG_NOTICE, "%s",
5123 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005124 }
5125 free_trash_chunk(tmptrash);
5126 tmptrash = NULL;
5127 }
5128
5129 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5130 set_backend_down(s->proxy);
5131 }
5132 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
5133 /* OK completely leaving drain mode */
5134 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
5135 if (s->proxy->last_change < now.tv_sec) // ignore negative times
5136 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
5137 s->proxy->last_change = now.tv_sec;
5138 }
5139
5140 if (s->last_change < now.tv_sec) // ignore negative times
5141 s->down_time += now.tv_sec - s->last_change;
5142 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005143 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005144
5145 tmptrash = alloc_trash_chunk();
5146 if (tmptrash) {
5147 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5148 chunk_printf(tmptrash,
5149 "%sServer %s/%s is %s (leaving forced drain)",
5150 s->flags & SRV_F_BACKUP ? "Backup " : "",
5151 s->proxy->id, s->id,
5152 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5153 }
5154 else {
5155 chunk_printf(tmptrash,
5156 "%sServer %s/%s is %s (leaving drain)",
5157 s->flags & SRV_F_BACKUP ? "Backup " : "",
5158 s->proxy->id, s->id,
5159 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5160 if (s->track) /* normally it's mandatory here */
5161 chunk_appendf(tmptrash, " via %s/%s",
5162 s->track->proxy->id, s->track->id);
5163 }
5164
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005165 ha_warning("%s.\n", tmptrash->area);
5166 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5167 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005168 free_trash_chunk(tmptrash);
5169 tmptrash = NULL;
5170 }
5171
5172 /* now propagate the status change to any LB algorithms */
5173 if (px->lbprm.update_server_eweight)
5174 px->lbprm.update_server_eweight(s);
5175 else if (srv_willbe_usable(s)) {
5176 if (px->lbprm.set_server_status_up)
5177 px->lbprm.set_server_status_up(s);
5178 }
5179 else {
5180 if (px->lbprm.set_server_status_down)
5181 px->lbprm.set_server_status_down(s);
5182 }
5183 }
5184 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
5185 /* remaining in drain mode after removing one of its flags */
5186
5187 tmptrash = alloc_trash_chunk();
5188 if (tmptrash) {
5189 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5190 chunk_printf(tmptrash,
5191 "%sServer %s/%s is leaving forced drain but remains in drain mode",
5192 s->flags & SRV_F_BACKUP ? "Backup " : "",
5193 s->proxy->id, s->id);
5194
5195 if (s->track) /* normally it's mandatory here */
5196 chunk_appendf(tmptrash, " via %s/%s",
5197 s->track->proxy->id, s->track->id);
5198 }
5199 else {
5200 chunk_printf(tmptrash,
5201 "%sServer %s/%s remains in forced drain mode",
5202 s->flags & SRV_F_BACKUP ? "Backup " : "",
5203 s->proxy->id, s->id);
5204 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005205 ha_warning("%s.\n", tmptrash->area);
5206 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5207 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005208 free_trash_chunk(tmptrash);
5209 tmptrash = NULL;
5210 }
5211
5212 /* commit new admin status */
5213
5214 s->cur_admin = s->next_admin;
5215 }
5216 }
5217
5218 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02005219 *s->adm_st_chg_cause = 0;
5220}
Emeric Brun64cc49c2017-10-03 14:46:45 +02005221
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005222struct task *srv_cleanup_toremove_connections(struct task *task, void *context, unsigned short state)
5223{
5224 struct connection *conn;
5225
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005226 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005227 struct connection *, list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02005228 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005229 }
5230
5231 return task;
5232}
5233
Olivier Houchardff1d0922020-06-29 20:15:59 +02005234/* Move toremove_nb connections from idle_list to toremove_list, -1 means
5235 * moving them all.
5236 * Returns the number of connections moved.
5237 */
5238static int srv_migrate_conns_to_remove(struct mt_list *idle_list, struct mt_list *toremove_list, int toremove_nb)
5239{
5240 struct mt_list *elt1, elt2;
5241 struct connection *conn;
5242 int i = 0;
5243
5244 mt_list_for_each_entry_safe(conn, idle_list, list, elt1, elt2) {
5245 if (toremove_nb != -1 && i >= toremove_nb)
5246 break;
5247 MT_LIST_DEL_SAFE_NOINIT(elt1);
Willy Tarreaude4db172020-07-10 08:10:29 +02005248 MT_LIST_ADDQ(toremove_list, &conn->list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005249 i++;
5250 }
5251 return i;
5252}
William Dauchy6318d332020-05-02 21:52:36 +02005253/* cleanup connections for a given server
5254 * might be useful when going on forced maintenance or live changing ip/port
5255 */
William Dauchy707ad322020-05-04 13:52:40 +02005256static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02005257{
William Dauchy6318d332020-05-02 21:52:36 +02005258 int did_remove;
5259 int i;
William Dauchy6318d332020-05-02 21:52:36 +02005260
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005261 /* check all threads starting with ours */
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005262 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02005263 did_remove = 0;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005264 if (srv_migrate_conns_to_remove(&srv->idle_conns[i], &idle_conns[i].toremove_conns, -1) > 0)
William Dauchy6318d332020-05-02 21:52:36 +02005265 did_remove = 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005266 if (srv_migrate_conns_to_remove(&srv->safe_conns[i], &idle_conns[i].toremove_conns, -1) > 0)
5267 did_remove = 1;
William Dauchy6318d332020-05-02 21:52:36 +02005268 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005269 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005270
5271 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5272 break;
William Dauchy6318d332020-05-02 21:52:36 +02005273 }
William Dauchy6318d332020-05-02 21:52:36 +02005274}
5275
Willy Tarreau980855b2019-02-07 14:59:29 +01005276struct task *srv_cleanup_idle_connections(struct task *task, void *context, unsigned short state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005277{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005278 struct server *srv;
5279 struct eb32_node *eb;
5280 int i;
5281 unsigned int next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005282
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005283 next_wakeup = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005284 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
5285 while (1) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005286 int exceed_conns;
5287 int to_kill;
5288 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005289
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005290 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
5291 if (!eb) {
5292 /* we might have reached the end of the tree, typically because
5293 * <now_ms> is in the first half and we're first scanning the last
5294 * half. Let's loop back to the beginning of the tree now.
5295 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005296
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005297 eb = eb32_first(&idle_conn_srv);
5298 if (likely(!eb))
5299 break;
5300 }
5301 if (tick_is_lt(now_ms, eb->key)) {
5302 /* timer not expired yet, revisit it later */
5303 next_wakeup = eb->key;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005304 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005305 }
5306 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005307
5308 /* Calculate how many idle connections we want to kill :
5309 * we want to remove half the difference between the total
5310 * of established connections (used or idle) and the max
5311 * number of used connections.
5312 */
5313 curr_idle = srv->curr_idle_conns;
5314 if (curr_idle == 0)
5315 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005316 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005317 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005318
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005319 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns) / 2;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005320 if (srv->est_need_conns < srv->max_used_conns)
5321 srv->est_need_conns = srv->max_used_conns;
5322
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005323 srv->max_used_conns = srv->curr_used_conns;
5324
Willy Tarreau18ed7892020-07-02 19:05:30 +02005325 if (exceed_conns <= 0)
5326 goto remove;
5327
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005328 /* check all threads starting with ours */
5329 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005330 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005331 int j;
5332 int did_remove = 0;
5333
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005334 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
5335 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005336
5337 j = srv_migrate_conns_to_remove(&srv->idle_conns[i], &idle_conns[i].toremove_conns, max_conn);
5338 if (j > 0)
5339 did_remove = 1;
5340 if (max_conn - j > 0 &&
5341 srv_migrate_conns_to_remove(&srv->safe_conns[i], &idle_conns[i].toremove_conns, max_conn - j) > 0)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005342 did_remove = 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005343
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005344 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005345 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005346
5347 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5348 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005349 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005350remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005351 eb32_delete(&srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005352
5353 if (srv->curr_idle_conns) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005354 /* There are still more idle connections, add the
5355 * server back in the tree.
5356 */
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005357 srv->idle_node.key = tick_add(srv->pool_purge_delay, now_ms);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005358 eb32_insert(&idle_conn_srv, &srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005359 next_wakeup = tick_first(next_wakeup, srv->idle_node.key);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005360 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005361 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005362 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5363
Willy Tarreau21b9ff52020-11-05 09:12:20 +01005364 task->expire = next_wakeup;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005365 return task;
5366}
Olivier Houchard88698d92019-04-16 19:07:22 +02005367
Willy Tarreau76cc6992020-07-01 18:49:24 +02005368/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
5369static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
5370 struct proxy *defpx, const char *file, int line,
5371 char **err)
5372{
5373 if (too_many_args(1, args, err, NULL))
5374 return -1;
5375
5376 if (strcmp(args[1], "on") == 0)
5377 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
5378 else if (strcmp(args[1], "off") == 0)
5379 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
5380 else {
5381 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
5382 return -1;
5383 }
5384 return 0;
5385}
5386
Olivier Houchard88698d92019-04-16 19:07:22 +02005387/* config parser for global "tune.pool-{low,high}-fd-ratio" */
5388static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
5389 struct proxy *defpx, const char *file, int line,
5390 char **err)
5391{
5392 int arg = -1;
5393
5394 if (too_many_args(1, args, err, NULL))
5395 return -1;
5396
5397 if (*(args[1]) != 0)
5398 arg = atoi(args[1]);
5399
5400 if (arg < 0 || arg > 100) {
5401 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
5402 return -1;
5403 }
5404
5405 if (args[0][10] == 'h')
5406 global.tune.pool_high_ratio = arg;
5407 else
5408 global.tune.pool_low_ratio = arg;
5409 return 0;
5410}
5411
5412/* config keyword parsers */
5413static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02005414 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02005415 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
5416 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
5417 { 0, NULL, NULL }
5418}};
5419
5420INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
5421
Baptiste Assmanna68ca962015-04-14 01:15:08 +02005422/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02005423 * Local variables:
5424 * c-indent-level: 8
5425 * c-basic-offset: 8
5426 * End:
5427 */