blob: 918294b2f4f98a054eeeecb0e5bf0a660f7e3c15 [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>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020041#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020042#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020043#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020044#include <haproxy/task.h>
Willy Tarreau51cd5952020-06-05 12:25:38 +020045#include <haproxy/tcpcheck.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020046#include <haproxy/time.h>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020047
Baptiste Assmannda29fe22019-06-13 13:24:29 +020048
Willy Tarreau3ff577e2018-08-02 11:48:52 +020049static void srv_update_status(struct server *s);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020050static void srv_update_state(struct server *srv, int version, char **params);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010051static int srv_apply_lastaddr(struct server *srv, int *err_code);
Olivier Houchardd16bfe62017-10-31 15:21:19 +010052static int srv_set_fqdn(struct server *srv, const char *fqdn, int dns_locked);
Baptiste Assmannda29fe22019-06-13 13:24:29 +020053static void srv_state_parse_line(char *buf, const int version, char **params, char **srv_params);
54static int srv_state_get_version(FILE *f);
William Dauchy6318d332020-05-02 21:52:36 +020055static void srv_cleanup_connections(struct server *srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +020056
Willy Tarreau21faa912012-10-10 08:27:36 +020057/* List head of all known server keywords */
58static struct srv_kw_list srv_keywords = {
59 .list = LIST_HEAD_INIT(srv_keywords.list)
60};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020061
Willy Tarreauaf613e82020-06-05 08:40:51 +020062__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010063struct eb_root idle_conn_srv = EB_ROOT;
64struct task *idle_conn_task = NULL;
Olivier Houchard9ea5d362019-02-14 18:29:09 +010065
Frédéric Lécaille7da71292019-05-20 09:47:07 +020066/* The server names dictionary */
67struct dict server_name_dict = {
68 .name = "server names",
69 .values = EB_ROOT_UNIQUE,
70};
71
Baptiste Assmannda29fe22019-06-13 13:24:29 +020072/* tree where global state_file is loaded */
Willy Tarreaufd1aa012019-12-20 17:23:40 +010073struct eb_root state_file = EB_ROOT_UNIQUE;
Baptiste Assmannda29fe22019-06-13 13:24:29 +020074
Simon Hormana3608442013-11-01 16:46:15 +090075int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020076{
Emeric Brun52a91d32017-08-31 14:41:55 +020077 if ((s->cur_state != SRV_ST_STOPPED) && s->last_change < now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020078 return s->down_time;
79
80 return now.tv_sec - s->last_change + s->down_time;
81}
Willy Tarreaubaaee002006-06-26 02:48:02 +020082
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050083int srv_lastsession(const struct server *s)
84{
85 if (s->counters.last_sess)
86 return now.tv_sec - s->counters.last_sess;
87
88 return -1;
89}
90
Simon Horman4a741432013-02-23 15:35:38 +090091int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020092{
Simon Horman4a741432013-02-23 15:35:38 +090093 const struct server *s = check->server;
94
Willy Tarreauff5ae352013-12-11 20:36:34 +010095 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090096 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010097
Emeric Brun52a91d32017-08-31 14:41:55 +020098 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +090099 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100100
Simon Horman4a741432013-02-23 15:35:38 +0900101 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100102}
103
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100104/*
105 * Check that we did not get a hash collision.
106 * Unlikely, but it can happen.
107 */
108static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +0100109{
110 struct proxy *p = s->proxy;
111 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100112
113 for (tmpserv = p->srv; tmpserv != NULL;
114 tmpserv = tmpserv->next) {
115 if (tmpserv == s)
116 continue;
117 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
118 continue;
119 if (tmpserv->cookie &&
120 strcmp(tmpserv->cookie, s->cookie) == 0) {
121 ha_warning("We generated two equal cookies for two different servers.\n"
122 "Please change the secret key for '%s'.\n",
123 s->proxy->id);
124 }
125 }
126
127}
128
Willy Tarreau46b7f532018-08-21 11:54:26 +0200129/*
Willy Tarreau5e83d992019-07-30 11:59:34 +0200130 * Must be called with the server lock held, and will grab the proxy lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200131 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100132void srv_set_dyncookie(struct server *s)
133{
134 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100135 char *tmpbuf;
136 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100137 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100138 size_t buffer_len;
139 int addr_len;
140 int port;
141
Willy Tarreau5e83d992019-07-30 11:59:34 +0200142 HA_SPIN_LOCK(PROXY_LOCK, &p->lock);
143
Olivier Houchard4e694042017-03-14 20:01:29 +0100144 if ((s->flags & SRV_F_COOKIESET) ||
145 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
146 s->proxy->dyncookie_key == NULL)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200147 goto out;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100148 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100149
150 if (s->addr.ss_family != AF_INET &&
151 s->addr.ss_family != AF_INET6)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200152 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100153 /*
154 * Buffer to calculate the cookie value.
155 * The buffer contains the secret key + the server IP address
156 * + the TCP port.
157 */
158 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
159 /*
160 * The TCP port should use only 2 bytes, but is stored in
161 * an unsigned int in struct server, so let's use 4, to be
162 * on the safe side.
163 */
164 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200165 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100166 memcpy(tmpbuf, p->dyncookie_key, key_len);
167 memcpy(&(tmpbuf[key_len]),
168 s->addr.ss_family == AF_INET ?
169 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
170 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
171 addr_len);
172 /*
173 * Make sure it's the same across all the load balancers,
174 * no matter their endianness.
175 */
176 port = htonl(s->svc_port);
177 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
178 hash_value = XXH64(tmpbuf, buffer_len, 0);
179 memprintf(&s->cookie, "%016llx", hash_value);
180 if (!s->cookie)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200181 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100182 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100183
184 /* Don't bother checking if the dyncookie is duplicated if
185 * the server is marked as "disabled", maybe it doesn't have
186 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100187 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100188 if (!(s->next_admin & SRV_ADMF_FMAINT))
189 srv_check_for_dup_dyncookie(s);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200190 out:
191 HA_SPIN_UNLOCK(PROXY_LOCK, &p->lock);
Olivier Houchard4e694042017-03-14 20:01:29 +0100192}
193
Willy Tarreau21faa912012-10-10 08:27:36 +0200194/*
195 * Registers the server keyword list <kwl> as a list of valid keywords for next
196 * parsing sessions.
197 */
198void srv_register_keywords(struct srv_kw_list *kwl)
199{
200 LIST_ADDQ(&srv_keywords.list, &kwl->list);
201}
202
203/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
204 * keyword is found with a NULL ->parse() function, then an attempt is made to
205 * find one with a valid ->parse() function. This way it is possible to declare
206 * platform-dependant, known keywords as NULL, then only declare them as valid
207 * if some options are met. Note that if the requested keyword contains an
208 * opening parenthesis, everything from this point is ignored.
209 */
210struct srv_kw *srv_find_kw(const char *kw)
211{
212 int index;
213 const char *kwend;
214 struct srv_kw_list *kwl;
215 struct srv_kw *ret = NULL;
216
217 kwend = strchr(kw, '(');
218 if (!kwend)
219 kwend = kw + strlen(kw);
220
221 list_for_each_entry(kwl, &srv_keywords.list, list) {
222 for (index = 0; kwl->kw[index].kw != NULL; index++) {
223 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
224 kwl->kw[index].kw[kwend-kw] == 0) {
225 if (kwl->kw[index].parse)
226 return &kwl->kw[index]; /* found it !*/
227 else
228 ret = &kwl->kw[index]; /* may be OK */
229 }
230 }
231 }
232 return ret;
233}
234
235/* Dumps all registered "server" keywords to the <out> string pointer. The
236 * unsupported keywords are only dumped if their supported form was not
237 * found.
238 */
239void srv_dump_kws(char **out)
240{
241 struct srv_kw_list *kwl;
242 int index;
243
Christopher Faulet784063e2020-05-18 12:14:18 +0200244 if (!out)
245 return;
246
Willy Tarreau21faa912012-10-10 08:27:36 +0200247 *out = NULL;
248 list_for_each_entry(kwl, &srv_keywords.list, list) {
249 for (index = 0; kwl->kw[index].kw != NULL; index++) {
250 if (kwl->kw[index].parse ||
251 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
252 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
253 kwl->scope,
254 kwl->kw[index].kw,
255 kwl->kw[index].skip ? " <arg>" : "",
256 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
257 kwl->kw[index].parse ? "" : " (not supported)");
258 }
259 }
260 }
261}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100262
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100263/* Parse the "backup" server keyword */
264static int srv_parse_backup(char **args, int *cur_arg,
265 struct proxy *curproxy, struct server *newsrv, char **err)
266{
267 newsrv->flags |= SRV_F_BACKUP;
268 return 0;
269}
270
Alexander Liu2a54bb72019-05-22 19:44:48 +0800271
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100272/* Parse the "cookie" server keyword */
273static int srv_parse_cookie(char **args, int *cur_arg,
274 struct proxy *curproxy, struct server *newsrv, char **err)
275{
276 char *arg;
277
278 arg = args[*cur_arg + 1];
279 if (!*arg) {
280 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
281 return ERR_ALERT | ERR_FATAL;
282 }
283
284 free(newsrv->cookie);
285 newsrv->cookie = strdup(arg);
286 newsrv->cklen = strlen(arg);
287 newsrv->flags |= SRV_F_COOKIESET;
288 return 0;
289}
290
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100291/* Parse the "disabled" server keyword */
292static int srv_parse_disabled(char **args, int *cur_arg,
293 struct proxy *curproxy, struct server *newsrv, char **err)
294{
Emeric Brun52a91d32017-08-31 14:41:55 +0200295 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
296 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100297 newsrv->check.state |= CHK_ST_PAUSED;
298 newsrv->check.health = 0;
299 return 0;
300}
301
302/* Parse the "enabled" server keyword */
303static int srv_parse_enabled(char **args, int *cur_arg,
304 struct proxy *curproxy, struct server *newsrv, char **err)
305{
Emeric Brun52a91d32017-08-31 14:41:55 +0200306 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
307 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100308 newsrv->check.state &= ~CHK_ST_PAUSED;
309 newsrv->check.health = newsrv->check.rise;
310 return 0;
311}
312
Willy Tarreau9c538e02019-01-23 10:21:49 +0100313static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
314{
315 char *arg;
316
317 arg = args[*cur_arg + 1];
318 if (!*arg) {
319 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
320 return ERR_ALERT | ERR_FATAL;
321 }
322 newsrv->max_reuse = atoi(arg);
323
324 return 0;
325}
326
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100327static 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 +0100328{
329 const char *res;
330 char *arg;
331 unsigned int time;
332
333 arg = args[*cur_arg + 1];
334 if (!*arg) {
335 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
336 return ERR_ALERT | ERR_FATAL;
337 }
338 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200339 if (res == PARSE_TIME_OVER) {
340 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
341 args[*cur_arg+1], args[*cur_arg]);
342 return ERR_ALERT | ERR_FATAL;
343 }
344 else if (res == PARSE_TIME_UNDER) {
345 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
346 args[*cur_arg+1], args[*cur_arg]);
347 return ERR_ALERT | ERR_FATAL;
348 }
349 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100350 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
351 *res, args[*cur_arg]);
352 return ERR_ALERT | ERR_FATAL;
353 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100354 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100355
356 return 0;
357}
358
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200359static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
360{
361 char *arg;
362
363 arg = args[*cur_arg + 1];
364 if (!*arg) {
365 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
366 return ERR_ALERT | ERR_FATAL;
367 }
368
369 newsrv->low_idle_conns = atoi(arg);
370 return 0;
371}
372
Olivier Houchard006e3102018-12-10 18:30:32 +0100373static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
374{
375 char *arg;
376
377 arg = args[*cur_arg + 1];
378 if (!*arg) {
379 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
380 return ERR_ALERT | ERR_FATAL;
381 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100382
Olivier Houchard006e3102018-12-10 18:30:32 +0100383 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100384 if ((int)newsrv->max_idle_conns < -1) {
385 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
386 return ERR_ALERT | ERR_FATAL;
387 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100388
389 return 0;
390}
391
Willy Tarreaudff55432012-10-10 17:51:05 +0200392/* parse the "id" server keyword */
393static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
394{
395 struct eb32_node *node;
396
397 if (!*args[*cur_arg + 1]) {
398 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
399 return ERR_ALERT | ERR_FATAL;
400 }
401
402 newsrv->puid = atol(args[*cur_arg + 1]);
403 newsrv->conf.id.key = newsrv->puid;
404
405 if (newsrv->puid <= 0) {
406 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
407 return ERR_ALERT | ERR_FATAL;
408 }
409
410 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
411 if (node) {
412 struct server *target = container_of(node, struct server, conf.id);
413 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
414 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
415 target->id);
416 return ERR_ALERT | ERR_FATAL;
417 }
418
419 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200420 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200421 return 0;
422}
423
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100424/* Parse the "namespace" server keyword */
425static int srv_parse_namespace(char **args, int *cur_arg,
426 struct proxy *curproxy, struct server *newsrv, char **err)
427{
Willy Tarreaue5733232019-05-22 19:24:06 +0200428#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100429 char *arg;
430
431 arg = args[*cur_arg + 1];
432 if (!*arg) {
433 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
434 return ERR_ALERT | ERR_FATAL;
435 }
436
437 if (!strcmp(arg, "*")) {
438 /* Use the namespace associated with the connection (if present). */
439 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
440 return 0;
441 }
442
443 /*
444 * As this parser may be called several times for the same 'default-server'
445 * object, or for a new 'server' instance deriving from a 'default-server'
446 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
447 */
448 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
449
450 newsrv->netns = netns_store_lookup(arg, strlen(arg));
451 if (!newsrv->netns)
452 newsrv->netns = netns_store_insert(arg);
453
454 if (!newsrv->netns) {
455 memprintf(err, "Cannot open namespace '%s'", arg);
456 return ERR_ALERT | ERR_FATAL;
457 }
458
459 return 0;
460#else
461 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
462 return ERR_ALERT | ERR_FATAL;
463#endif
464}
465
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100466/* Parse the "no-backup" server keyword */
467static int srv_parse_no_backup(char **args, int *cur_arg,
468 struct proxy *curproxy, struct server *newsrv, char **err)
469{
470 newsrv->flags &= ~SRV_F_BACKUP;
471 return 0;
472}
473
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100474
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100475/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200476static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100477{
478 srv->pp_opts &= ~flags;
479 return 0;
480}
481
482/* Parse the "no-send-proxy" server keyword */
483static int srv_parse_no_send_proxy(char **args, int *cur_arg,
484 struct proxy *curproxy, struct server *newsrv, char **err)
485{
486 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
487}
488
489/* Parse the "no-send-proxy-v2" server keyword */
490static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
491 struct proxy *curproxy, struct server *newsrv, char **err)
492{
493 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
494}
495
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200496/* Parse the "no-tfo" server keyword */
497static int srv_parse_no_tfo(char **args, int *cur_arg,
498 struct proxy *curproxy, struct server *newsrv, char **err)
499{
500 newsrv->flags &= ~SRV_F_FASTOPEN;
501 return 0;
502}
503
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100504/* Parse the "non-stick" server keyword */
505static int srv_parse_non_stick(char **args, int *cur_arg,
506 struct proxy *curproxy, struct server *newsrv, char **err)
507{
508 newsrv->flags |= SRV_F_NON_STICK;
509 return 0;
510}
511
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100512/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200513static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100514{
515 srv->pp_opts |= flags;
516 return 0;
517}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200518/* parse the "proto" server keyword */
519static int srv_parse_proto(char **args, int *cur_arg,
520 struct proxy *px, struct server *newsrv, char **err)
521{
522 struct ist proto;
523
524 if (!*args[*cur_arg + 1]) {
525 memprintf(err, "'%s' : missing value", args[*cur_arg]);
526 return ERR_ALERT | ERR_FATAL;
527 }
528 proto = ist2(args[*cur_arg + 1], strlen(args[*cur_arg + 1]));
529 newsrv->mux_proto = get_mux_proto(proto);
530 if (!newsrv->mux_proto) {
531 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
532 return ERR_ALERT | ERR_FATAL;
533 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200534 return 0;
535}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100536
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100537/* parse the "proxy-v2-options" */
538static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
539 struct proxy *px, struct server *newsrv, char **err)
540{
541 char *p, *n;
542 for (p = args[*cur_arg+1]; p; p = n) {
543 n = strchr(p, ',');
544 if (n)
545 *n++ = '\0';
546 if (!strcmp(p, "ssl")) {
547 newsrv->pp_opts |= SRV_PP_V2_SSL;
548 } else if (!strcmp(p, "cert-cn")) {
549 newsrv->pp_opts |= SRV_PP_V2_SSL;
550 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100551 } else if (!strcmp(p, "cert-key")) {
552 newsrv->pp_opts |= SRV_PP_V2_SSL;
553 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
554 } else if (!strcmp(p, "cert-sig")) {
555 newsrv->pp_opts |= SRV_PP_V2_SSL;
556 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
557 } else if (!strcmp(p, "ssl-cipher")) {
558 newsrv->pp_opts |= SRV_PP_V2_SSL;
559 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100560 } else if (!strcmp(p, "authority")) {
561 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100562 } else if (!strcmp(p, "crc32c")) {
563 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100564 } else if (!strcmp(p, "unique-id")) {
565 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100566 } else
567 goto fail;
568 }
569 return 0;
570 fail:
571 if (err)
572 memprintf(err, "'%s' : proxy v2 option not implemented", p);
573 return ERR_ALERT | ERR_FATAL;
574}
575
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100576/* Parse the "observe" server keyword */
577static int srv_parse_observe(char **args, int *cur_arg,
578 struct proxy *curproxy, struct server *newsrv, char **err)
579{
580 char *arg;
581
582 arg = args[*cur_arg + 1];
583 if (!*arg) {
584 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
585 return ERR_ALERT | ERR_FATAL;
586 }
587
588 if (!strcmp(arg, "none")) {
589 newsrv->observe = HANA_OBS_NONE;
590 }
591 else if (!strcmp(arg, "layer4")) {
592 newsrv->observe = HANA_OBS_LAYER4;
593 }
594 else if (!strcmp(arg, "layer7")) {
595 if (curproxy->mode != PR_MODE_HTTP) {
596 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
597 return ERR_ALERT;
598 }
599 newsrv->observe = HANA_OBS_LAYER7;
600 }
601 else {
602 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
603 "but got '%s'\n", args[*cur_arg], arg);
604 return ERR_ALERT | ERR_FATAL;
605 }
606
607 return 0;
608}
609
Frédéric Lécaille16186232017-03-14 16:42:49 +0100610/* Parse the "redir" server keyword */
611static int srv_parse_redir(char **args, int *cur_arg,
612 struct proxy *curproxy, struct server *newsrv, char **err)
613{
614 char *arg;
615
616 arg = args[*cur_arg + 1];
617 if (!*arg) {
618 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
619 return ERR_ALERT | ERR_FATAL;
620 }
621
622 free(newsrv->rdr_pfx);
623 newsrv->rdr_pfx = strdup(arg);
624 newsrv->rdr_len = strlen(arg);
625
626 return 0;
627}
628
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100629/* Parse the "send-proxy" server keyword */
630static int srv_parse_send_proxy(char **args, int *cur_arg,
631 struct proxy *curproxy, struct server *newsrv, char **err)
632{
633 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
634}
635
636/* Parse the "send-proxy-v2" server keyword */
637static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
638 struct proxy *curproxy, struct server *newsrv, char **err)
639{
640 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
641}
642
Frédéric Lécailledba97072017-03-17 15:33:50 +0100643
644/* Parse the "source" server keyword */
645static int srv_parse_source(char **args, int *cur_arg,
646 struct proxy *curproxy, struct server *newsrv, char **err)
647{
648 char *errmsg;
649 int port_low, port_high;
650 struct sockaddr_storage *sk;
651 struct protocol *proto;
652
653 errmsg = NULL;
654
655 if (!*args[*cur_arg + 1]) {
656 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
657 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
658 goto err;
659 }
660
661 /* 'sk' is statically allocated (no need to be freed). */
662 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, &errmsg, NULL, NULL, 1);
663 if (!sk) {
664 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
665 goto err;
666 }
667
668 proto = protocol_by_family(sk->ss_family);
669 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100670 ha_alert("'%s %s' : connect() not supported for this address family.\n",
671 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100672 goto err;
673 }
674
675 newsrv->conn_src.opts |= CO_SRC_BIND;
676 newsrv->conn_src.source_addr = *sk;
677
678 if (port_low != port_high) {
679 int i;
680
681 if (!port_low || !port_high) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100682 ha_alert("'%s' does not support port offsets (found '%s').\n",
683 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100684 goto err;
685 }
686
687 if (port_low <= 0 || port_low > 65535 ||
688 port_high <= 0 || port_high > 65535 ||
689 port_low > port_high) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100690 ha_alert("'%s': invalid source port range %d-%d.\n", args[*cur_arg], port_low, port_high);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100691 goto err;
692 }
693 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
694 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
695 newsrv->conn_src.sport_range->ports[i] = port_low + i;
696 }
697
698 *cur_arg += 2;
699 while (*(args[*cur_arg])) {
700 if (!strcmp(args[*cur_arg], "usesrc")) { /* address to use outside */
701#if defined(CONFIG_HAP_TRANSPARENT)
702 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100703 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
704 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100705 goto err;
706 }
707 if (!strcmp(args[*cur_arg + 1], "client")) {
708 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
709 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
710 }
711 else if (!strcmp(args[*cur_arg + 1], "clientip")) {
712 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
713 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
714 }
715 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
716 char *name, *end;
717
718 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +0100719 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100720 name++;
721
722 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +0100723 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +0100724 end++;
725
726 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
727 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
728 free(newsrv->conn_src.bind_hdr_name);
729 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
730 newsrv->conn_src.bind_hdr_len = end - name;
731 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
732 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
733 newsrv->conn_src.bind_hdr_occ = -1;
734
735 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +0100736 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100737 end++;
738 if (*end == ',') {
739 end++;
740 name = end;
741 if (*end == '-')
742 end++;
Willy Tarreau90807112020-02-25 08:16:33 +0100743 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100744 end++;
745 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
746 }
747
748 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100749 ha_alert("usesrc hdr_ip(name,num) does not support negative"
750 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100751 goto err;
752 }
753 }
754 else {
755 struct sockaddr_storage *sk;
756 int port1, port2;
757
758 /* 'sk' is statically allocated (no need to be freed). */
759 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
760 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100761 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100762 goto err;
763 }
764
765 proto = protocol_by_family(sk->ss_family);
766 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100767 ha_alert("'%s %s' : connect() not supported for this address family.\n",
768 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100769 goto err;
770 }
771
772 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100773 ha_alert("'%s' : port ranges and offsets are not allowed in '%s'\n",
774 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100775 goto err;
776 }
777 newsrv->conn_src.tproxy_addr = *sk;
778 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
779 }
780 global.last_checks |= LSTCHK_NETADM;
781 *cur_arg += 2;
782 continue;
783#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100784 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 +0100785 goto err;
786#endif /* defined(CONFIG_HAP_TRANSPARENT) */
787 } /* "usesrc" */
788
789 if (!strcmp(args[*cur_arg], "interface")) { /* specifically bind to this interface */
790#ifdef SO_BINDTODEVICE
791 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100792 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100793 goto err;
794 }
795 free(newsrv->conn_src.iface_name);
796 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
797 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
798 global.last_checks |= LSTCHK_NETADM;
799#else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100800 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100801 goto err;
802#endif
803 *cur_arg += 2;
804 continue;
805 }
806 /* this keyword in not an option of "source" */
807 break;
808 } /* while */
809
810 return 0;
811
812 err:
813 free(errmsg);
814 return ERR_ALERT | ERR_FATAL;
815}
816
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100817/* Parse the "stick" server keyword */
818static int srv_parse_stick(char **args, int *cur_arg,
819 struct proxy *curproxy, struct server *newsrv, char **err)
820{
821 newsrv->flags &= ~SRV_F_NON_STICK;
822 return 0;
823}
824
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100825/* Parse the "track" server keyword */
826static int srv_parse_track(char **args, int *cur_arg,
827 struct proxy *curproxy, struct server *newsrv, char **err)
828{
829 char *arg;
830
831 arg = args[*cur_arg + 1];
832 if (!*arg) {
833 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
834 return ERR_ALERT | ERR_FATAL;
835 }
836
837 free(newsrv->trackit);
838 newsrv->trackit = strdup(arg);
839
840 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800841}
842
843/* Parse the "socks4" server keyword */
844static int srv_parse_socks4(char **args, int *cur_arg,
845 struct proxy *curproxy, struct server *newsrv, char **err)
846{
847 char *errmsg;
848 int port_low, port_high;
849 struct sockaddr_storage *sk;
850 struct protocol *proto;
851
852 errmsg = NULL;
853
854 if (!*args[*cur_arg + 1]) {
855 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
856 goto err;
857 }
858
859 /* 'sk' is statically allocated (no need to be freed). */
860 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, &errmsg, NULL, NULL, 1);
861 if (!sk) {
862 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
863 goto err;
864 }
865
866 proto = protocol_by_family(sk->ss_family);
867 if (!proto || !proto->connect) {
868 ha_alert("'%s %s' : connect() not supported for this address family.\n", args[*cur_arg], args[*cur_arg + 1]);
869 goto err;
870 }
871
872 newsrv->flags |= SRV_F_SOCKS4_PROXY;
873 newsrv->socks4_addr = *sk;
874
875 if (port_low != port_high) {
876 ha_alert("'%s' does not support port offsets (found '%s').\n", args[*cur_arg], args[*cur_arg + 1]);
877 goto err;
878 }
879
880 if (!port_low) {
881 ha_alert("'%s': invalid port range %d-%d.\n", args[*cur_arg], port_low, port_high);
882 goto err;
883 }
884
885 return 0;
886
887 err:
888 free(errmsg);
889 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100890}
891
Frédéric Lécailledba97072017-03-17 15:33:50 +0100892
Willy Tarreau034c88c2017-01-23 23:36:45 +0100893/* parse the "tfo" server keyword */
894static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
895{
896 newsrv->flags |= SRV_F_FASTOPEN;
897 return 0;
898}
899
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200900/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200901 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200902 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200903 *
904 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200905 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200906void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200907{
Willy Tarreau87b09662015-04-03 00:22:06 +0200908 struct stream *stream, *stream_bck;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200909
Willy Tarreau87b09662015-04-03 00:22:06 +0200910 list_for_each_entry_safe(stream, stream_bck, &srv->actconns, by_srv)
911 if (stream->srv_conn == srv)
912 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200913}
914
915/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200916 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200917 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200918 *
919 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200920 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200921void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200922{
923 struct server *srv;
924
925 for (srv = px->srv; srv != NULL; srv = srv->next)
926 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200927 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200928}
929
Willy Tarreaubda92272014-05-20 21:55:30 +0200930/* Appends some information to a message string related to a server going UP or
931 * DOWN. If both <forced> and <reason> are null and the server tracks another
932 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +0200933 * If <check> is non-null, an entire string describing the check result will be
934 * appended after a comma and a space (eg: to report some information from the
935 * check that changed the state). In the other case, the string will be built
936 * using the check results stored into the struct server if present.
937 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +0200938 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200939 *
940 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200941 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200942void srv_append_status(struct buffer *msg, struct server *s,
943 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200944{
Emeric Brun5a133512017-10-19 14:42:30 +0200945 short status = s->op_st_chg.status;
946 short code = s->op_st_chg.code;
947 long duration = s->op_st_chg.duration;
948 char *desc = s->op_st_chg.reason;
949
950 if (check) {
951 status = check->status;
952 code = check->code;
953 duration = check->duration;
954 desc = check->desc;
955 }
956
957 if (status != -1) {
958 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
959
960 if (status >= HCHK_STATUS_L57DATA)
961 chunk_appendf(msg, ", code: %d", code);
962
963 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200964 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +0200965
966 chunk_appendf(msg, ", info: \"");
967
968 chunk_initlen(&src, desc, 0, strlen(desc));
969 chunk_asciiencode(msg, &src, '"');
970
971 chunk_appendf(msg, "\"");
972 }
973
974 if (duration >= 0)
975 chunk_appendf(msg, ", check duration: %ldms", duration);
976 }
977 else if (desc && *desc) {
978 chunk_appendf(msg, ", %s", desc);
979 }
980 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +0200981 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +0200982 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200983
984 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200985 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200986 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
987 " %d sessions active, %d requeued, %d remaining in queue",
988 s->proxy->srv_act, s->proxy->srv_bck,
989 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
990 s->cur_sess, xferred, s->nbpend);
991 else
992 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
993 " %d sessions requeued, %d total in queue",
994 s->proxy->srv_act, s->proxy->srv_bck,
995 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
996 xferred, s->nbpend);
997 }
998}
999
Emeric Brun5a133512017-10-19 14:42:30 +02001000/* Marks server <s> down, regardless of its checks' statuses. The server is
1001 * registered in a list to postpone the counting of the remaining servers on
1002 * the proxy and transfers queued streams whenever possible to other servers at
1003 * a sync point. Maintenance servers are ignored. It stores the <reason> if
1004 * non-null as the reason for going down or the available data from the check
1005 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001006 *
1007 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001008 */
Emeric Brun5a133512017-10-19 14:42:30 +02001009void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001010{
1011 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001012
Emeric Brun64cc49c2017-10-03 14:46:45 +02001013 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001014 return;
1015
Emeric Brun52a91d32017-08-31 14:41:55 +02001016 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001017 *s->op_st_chg.reason = 0;
1018 s->op_st_chg.status = -1;
1019 if (reason) {
1020 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1021 }
1022 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001023 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001024 s->op_st_chg.code = check->code;
1025 s->op_st_chg.status = check->status;
1026 s->op_st_chg.duration = check->duration;
1027 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001028
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001029 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001030 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001031
Emeric Brun9f0b4582017-10-23 14:39:51 +02001032 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001033 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001034 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001035 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001036 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001037}
1038
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001039/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001040 * in maintenance. The server is registered in a list to postpone the counting
1041 * of the remaining servers on the proxy and tries to grab requests from the
1042 * proxy at a sync point. Maintenance servers are ignored. It stores the
1043 * <reason> if non-null as the reason for going down or the available data
1044 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001045 *
1046 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001047 */
Emeric Brun5a133512017-10-19 14:42:30 +02001048void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001049{
1050 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001051
Emeric Brun64cc49c2017-10-03 14:46:45 +02001052 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001053 return;
1054
Emeric Brun52a91d32017-08-31 14:41:55 +02001055 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001056 return;
1057
Emeric Brun52a91d32017-08-31 14:41:55 +02001058 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001059 *s->op_st_chg.reason = 0;
1060 s->op_st_chg.status = -1;
1061 if (reason) {
1062 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1063 }
1064 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001065 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001066 s->op_st_chg.code = check->code;
1067 s->op_st_chg.status = check->status;
1068 s->op_st_chg.duration = check->duration;
1069 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001070
Emeric Brun64cc49c2017-10-03 14:46:45 +02001071 if (s->slowstart <= 0)
1072 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001073
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001074 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001075 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001076
Emeric Brun9f0b4582017-10-23 14:39:51 +02001077 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001078 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001079 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001080 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001081 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001082}
1083
Willy Tarreau8eb77842014-05-21 13:54:57 +02001084/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001085 * isn't in maintenance. The server is registered in a list to postpone the
1086 * counting of the remaining servers on the proxy and tries to grab requests
1087 * from the proxy. Maintenance servers are ignored. It stores the
1088 * <reason> if non-null as the reason for going down or the available data
1089 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001090 * up. Note that it makes use of the trash to build the log strings, so <reason>
1091 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001092 *
1093 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001094 */
Emeric Brun5a133512017-10-19 14:42:30 +02001095void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001096{
1097 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001098
Emeric Brun64cc49c2017-10-03 14:46:45 +02001099 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001100 return;
1101
Emeric Brun52a91d32017-08-31 14:41:55 +02001102 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001103 return;
1104
Emeric Brun52a91d32017-08-31 14:41:55 +02001105 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001106 *s->op_st_chg.reason = 0;
1107 s->op_st_chg.status = -1;
1108 if (reason) {
1109 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1110 }
1111 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001112 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001113 s->op_st_chg.code = check->code;
1114 s->op_st_chg.status = check->status;
1115 s->op_st_chg.duration = check->duration;
1116 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001117
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001118 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001119 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001120
Emeric Brun9f0b4582017-10-23 14:39:51 +02001121 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001122 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001123 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001124 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001125 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001126}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001127
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001128/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1129 * enforce either maint mode or drain mode. It is not allowed to set more than
1130 * one flag at once. The equivalent "inherited" flag is propagated to all
1131 * tracking servers. Maintenance mode disables health checks (but not agent
1132 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001133 * is done. If <cause> is non-null, it will be displayed at the end of the log
1134 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001135 *
1136 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001137 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001138void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001139{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001140 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001141
1142 if (!mode)
1143 return;
1144
1145 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001146 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001147 return;
1148
Emeric Brun52a91d32017-08-31 14:41:55 +02001149 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001150 if (cause)
1151 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1152
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001153 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001154 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001155
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001156 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001157 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1158 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001159 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001160
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001161 /* compute the inherited flag to propagate */
1162 if (mode & SRV_ADMF_MAINT)
1163 mode = SRV_ADMF_IMAINT;
1164 else if (mode & SRV_ADMF_DRAIN)
1165 mode = SRV_ADMF_IDRAIN;
1166
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 Tarreau8b428482016-11-07 15:53:43 +01001169 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +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 Tarreaubfc7b7a2014-05-22 16:14:34 +02001174/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1175 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1176 * than one flag at once. The equivalent "inherited" flag is propagated to all
1177 * tracking servers. Leaving maintenance mode re-enables health checks. When
1178 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001179 *
1180 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001181 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001182void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001183{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001184 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001185
1186 if (!mode)
1187 return;
1188
1189 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001190 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001191 return;
1192
Emeric Brun52a91d32017-08-31 14:41:55 +02001193 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001194
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001195 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001196 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001197
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001198 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001199 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1200 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001201 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001202
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001203 if (mode & SRV_ADMF_MAINT)
1204 mode = SRV_ADMF_IMAINT;
1205 else if (mode & SRV_ADMF_DRAIN)
1206 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001207
Emeric Brun9f0b4582017-10-23 14:39:51 +02001208 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001209 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001210 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001211 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001212 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001213}
1214
Willy Tarreau757478e2016-11-03 19:22:19 +01001215/* principle: propagate maint and drain to tracking servers. This is useful
1216 * upon startup so that inherited states are correct.
1217 */
1218static void srv_propagate_admin_state(struct server *srv)
1219{
1220 struct server *srv2;
1221
1222 if (!srv->trackers)
1223 return;
1224
1225 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001226 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001227 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001228 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001229
Emeric Brun52a91d32017-08-31 14:41:55 +02001230 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001231 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001232 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001233 }
1234}
1235
1236/* Compute and propagate the admin states for all servers in proxy <px>.
1237 * Only servers *not* tracking another one are considered, because other
1238 * ones will be handled when the server they track is visited.
1239 */
1240void srv_compute_all_admin_states(struct proxy *px)
1241{
1242 struct server *srv;
1243
1244 for (srv = px->srv; srv; srv = srv->next) {
1245 if (srv->track)
1246 continue;
1247 srv_propagate_admin_state(srv);
1248 }
1249}
1250
Willy Tarreaudff55432012-10-10 17:51:05 +02001251/* Note: must not be declared <const> as its list will be overwritten.
1252 * Please take care of keeping this list alphabetically sorted, doing so helps
1253 * all code contributors.
1254 * Optional keywords are also declared with a NULL ->parse() function so that
1255 * the config parser can report an appropriate error when a known keyword was
1256 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001257 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001258 */
1259static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001260 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +01001261 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001262 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1263 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001264 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Willy Tarreau9c538e02019-01-23 10:21:49 +01001265 { "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 +01001266 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001267 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001268 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1269 { "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 +02001270 { "no-tfo", srv_parse_no_tfo, 0, 1 }, /* Disable use of TCP Fast Open */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001271 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001272 { "observe", srv_parse_observe, 1, 1 }, /* Enables health adjusting based on observing communication with the server */
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001273 { "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 +01001274 { "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 +01001275 { "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 +02001276 { "proto", srv_parse_proto, 1, 1 }, /* Set the proto to use for all outgoing connections */
Emmanuel Hocdetf643b802018-02-01 15:20:32 +01001277 { "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 +01001278 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001279 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1280 { "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 +02001281 { "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 +01001282 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Olivier Houchard8d82db72019-07-04 13:34:10 +02001283 { "tfo", srv_parse_tfo, 0, 1 }, /* enable TCP Fast Open of server */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001284 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Alexander Liu2a54bb72019-05-22 19:44:48 +08001285 { "socks4", srv_parse_socks4, 1, 1 }, /* Set the socks4 proxy of the server*/
Willy Tarreaudff55432012-10-10 17:51:05 +02001286 { NULL, NULL, 0 },
1287}};
1288
Willy Tarreau0108d902018-11-25 19:14:37 +01001289INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001290
Willy Tarreau004e0452013-11-21 11:22:01 +01001291/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001292 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001293 * state is automatically disabled if the time is elapsed. If <must_update> is
1294 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001295 *
1296 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001297 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001298void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001299{
1300 struct proxy *px = sv->proxy;
1301 unsigned w;
1302
1303 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1304 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001305 if (sv->next_state == SRV_ST_STARTING)
1306 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001307 }
1308
1309 /* We must take care of not pushing the server to full throttle during slow starts.
1310 * It must also start immediately, at least at the minimal step when leaving maintenance.
1311 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001312 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001313 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1314 else
1315 w = px->lbprm.wdiv;
1316
Emeric Brun52a91d32017-08-31 14:41:55 +02001317 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001318
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001319 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001320 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001321 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001322}
1323
Willy Tarreaubaaee002006-06-26 02:48:02 +02001324/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001325 * Parses weight_str and configures sv accordingly.
1326 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001327 *
1328 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001329 */
1330const char *server_parse_weight_change_request(struct server *sv,
1331 const char *weight_str)
1332{
1333 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001334 long int w;
1335 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001336
1337 px = sv->proxy;
1338
1339 /* if the weight is terminated with '%', it is set relative to
1340 * the initial weight, otherwise it is absolute.
1341 */
1342 if (!*weight_str)
1343 return "Require <weight> or <weight%>.\n";
1344
Simon Hormanb796afa2013-02-12 10:45:53 +09001345 w = strtol(weight_str, &end, 10);
1346 if (end == weight_str)
1347 return "Empty weight string empty or preceded by garbage";
1348 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001349 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001350 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001351 /* Avoid integer overflow */
1352 if (w > 25600)
1353 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001354 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001355 if (w > 256)
1356 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001357 }
1358 else if (w < 0 || w > 256)
1359 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001360 else if (end[0] != '\0')
1361 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001362
1363 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1364 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1365
1366 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001367 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001368
1369 return NULL;
1370}
1371
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001372/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001373 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1374 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001375 * Returns:
1376 * - error string on error
1377 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001378 *
1379 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001380 */
1381const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001382 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001383{
1384 unsigned char ip[INET6_ADDRSTRLEN];
1385
1386 if (inet_pton(AF_INET6, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001387 update_server_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001388 return NULL;
1389 }
1390 if (inet_pton(AF_INET, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001391 update_server_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001392 return NULL;
1393 }
1394
1395 return "Could not understand IP address format.\n";
1396}
1397
Willy Tarreau46b7f532018-08-21 11:54:26 +02001398/*
1399 * Must be called with the server lock held.
1400 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001401const char *server_parse_maxconn_change_request(struct server *sv,
1402 const char *maxconn_str)
1403{
1404 long int v;
1405 char *end;
1406
1407 if (!*maxconn_str)
1408 return "Require <maxconn>.\n";
1409
1410 v = strtol(maxconn_str, &end, 10);
1411 if (end == maxconn_str)
1412 return "maxconn string empty or preceded by garbage";
1413 else if (end[0] != '\0')
1414 return "Trailing garbage in maxconn string";
1415
1416 if (sv->maxconn == sv->minconn) { // static maxconn
1417 sv->maxconn = sv->minconn = v;
1418 } else { // dynamic maxconn
1419 sv->maxconn = v;
1420 }
1421
1422 if (may_dequeue_tasks(sv, sv->proxy))
1423 process_srv_queue(sv);
1424
1425 return NULL;
1426}
1427
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001428#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001429static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1430 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001431{
1432 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001433 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001434 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001435 NULL,
1436 };
1437
1438 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001439 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001440
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001441 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001442}
1443
1444static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1445{
1446 struct sample_expr *expr;
1447
1448 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 +01001449 if (!expr) {
1450 memprintf(err, "error detected while parsing sni expression : %s", *err);
1451 return ERR_ALERT | ERR_FATAL;
1452 }
1453
1454 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1455 memprintf(err, "error detected while parsing sni expression : "
1456 " fetch method '%s' extracts information from '%s', "
1457 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001458 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001459 return ERR_ALERT | ERR_FATAL;
1460 }
1461
1462 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1463 release_sample_expr(newsrv->ssl_ctx.sni);
1464 newsrv->ssl_ctx.sni = expr;
1465
1466 return 0;
1467}
1468#endif
1469
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001470static 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 +01001471{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001472 char *msg = "error encountered while processing ";
1473 char *quote = "'";
1474 char *token = args[cur_arg];
1475
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001476 if (err && *err) {
1477 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001478 msg = *err;
1479 quote = "";
1480 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001481 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001482
1483 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
1484 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1485 file, linenum, args[0], args[1],
1486 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001487 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001488 ha_alert("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1489 file, linenum, args[0], args[1],
1490 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001491}
1492
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001493static void srv_conn_src_sport_range_cpy(struct server *srv,
1494 struct server *src)
1495{
1496 int range_sz;
1497
1498 range_sz = src->conn_src.sport_range->size;
1499 if (range_sz > 0) {
1500 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1501 if (srv->conn_src.sport_range != NULL) {
1502 int i;
1503
1504 for (i = 0; i < range_sz; i++) {
1505 srv->conn_src.sport_range->ports[i] =
1506 src->conn_src.sport_range->ports[i];
1507 }
1508 }
1509 }
1510}
1511
1512/*
1513 * Copy <src> server connection source settings to <srv> server everything needed.
1514 */
1515static void srv_conn_src_cpy(struct server *srv, struct server *src)
1516{
1517 srv->conn_src.opts = src->conn_src.opts;
1518 srv->conn_src.source_addr = src->conn_src.source_addr;
1519
1520 /* Source port range copy. */
1521 if (src->conn_src.sport_range != NULL)
1522 srv_conn_src_sport_range_cpy(srv, src);
1523
1524#ifdef CONFIG_HAP_TRANSPARENT
1525 if (src->conn_src.bind_hdr_name != NULL) {
1526 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1527 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1528 }
1529 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1530 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1531#endif
1532 if (src->conn_src.iface_name != NULL)
1533 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1534}
1535
1536/*
1537 * Copy <src> server SSL settings to <srv> server allocating
1538 * everything needed.
1539 */
1540#if defined(USE_OPENSSL)
1541static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1542{
1543 if (src->ssl_ctx.ca_file != NULL)
1544 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1545 if (src->ssl_ctx.crl_file != NULL)
1546 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
1547 if (src->ssl_ctx.client_crt != NULL)
1548 srv->ssl_ctx.client_crt = strdup(src->ssl_ctx.client_crt);
1549
1550 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1551
1552 if (src->ssl_ctx.verify_host != NULL)
1553 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1554 if (src->ssl_ctx.ciphers != NULL)
1555 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02001556 if (src->ssl_ctx.options)
1557 srv->ssl_ctx.options = src->ssl_ctx.options;
1558 if (src->ssl_ctx.methods.flags)
1559 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
1560 if (src->ssl_ctx.methods.min)
1561 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
1562 if (src->ssl_ctx.methods.max)
1563 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
1564
Willy Tarreau5db847a2019-05-09 14:13:35 +02001565#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L && !defined OPENSSL_IS_BORINGSSL)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001566 if (src->ssl_ctx.ciphersuites != NULL)
1567 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
1568#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001569 if (src->sni_expr != NULL)
1570 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001571
1572#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
1573 if (src->ssl_ctx.alpn_str) {
1574 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1575 if (srv->ssl_ctx.alpn_str) {
1576 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1577 src->ssl_ctx.alpn_len);
1578 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1579 }
1580 }
1581#endif
1582#ifdef OPENSSL_NPN_NEGOTIATED
1583 if (src->ssl_ctx.npn_str) {
1584 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1585 if (srv->ssl_ctx.npn_str) {
1586 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1587 src->ssl_ctx.npn_len);
1588 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1589 }
1590 }
1591#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001592}
1593#endif
1594
1595/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001596 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001597 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001598 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001599 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001600static int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001601{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001602 char *hostname_dn;
1603 int hostname_len, hostname_dn_len;
1604
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001605 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001606 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001607
Christopher Faulet67957bd2017-09-27 11:00:59 +02001608 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001609 hostname_dn = trash.area;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001610 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
1611 hostname_dn, trash.size);
1612 if (hostname_dn_len == -1)
1613 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001614
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001615
Christopher Faulet67957bd2017-09-27 11:00:59 +02001616 free(srv->hostname);
1617 free(srv->hostname_dn);
1618 srv->hostname = strdup(hostname);
1619 srv->hostname_dn = strdup(hostname_dn);
1620 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001621 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001622 goto err;
1623
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001624 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001625
1626 err:
Christopher Faulet67957bd2017-09-27 11:00:59 +02001627 free(srv->hostname); srv->hostname = NULL;
1628 free(srv->hostname_dn); srv->hostname_dn = NULL;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001629 return -1;
1630}
1631
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001632/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001633 * Copy <src> server settings to <srv> server allocating
1634 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001635 * This function is not supposed to be called at any time, but only
1636 * during server settings parsing or during server allocations from
1637 * a server template, and just after having calloc()'ed a new server.
1638 * So, <src> may only be a default server (when parsing server settings)
1639 * or a server template (during server allocations from a server template).
1640 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1641 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001642 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001643static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001644{
1645 /* Connection source settings copy */
1646 srv_conn_src_cpy(srv, src);
1647
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001648 if (srv_tmpl) {
1649 srv->addr = src->addr;
1650 srv->svc_port = src->svc_port;
1651 }
1652
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001653 srv->pp_opts = src->pp_opts;
1654 if (src->rdr_pfx != NULL) {
1655 srv->rdr_pfx = strdup(src->rdr_pfx);
1656 srv->rdr_len = src->rdr_len;
1657 }
1658 if (src->cookie != NULL) {
1659 srv->cookie = strdup(src->cookie);
1660 srv->cklen = src->cklen;
1661 }
1662 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01001663 srv->check.addr = src->check.addr;
1664 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001665 srv->check.use_ssl = src->check.use_ssl;
1666 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01001667 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01001668 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05001669 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001670 /* Note: 'flags' field has potentially been already initialized. */
1671 srv->flags |= src->flags;
1672 srv->do_check = src->do_check;
1673 srv->do_agent = src->do_agent;
1674 if (srv->check.port)
1675 srv->flags |= SRV_F_CHECKPORT;
1676 srv->check.inter = src->check.inter;
1677 srv->check.fastinter = src->check.fastinter;
1678 srv->check.downinter = src->check.downinter;
1679 srv->agent.use_ssl = src->agent.use_ssl;
1680 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001681
1682 if (src->agent.tcpcheck_rules) {
1683 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
1684 if (srv->agent.tcpcheck_rules) {
1685 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
1686 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
1687 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
1688 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
1689 &src->agent.tcpcheck_rules->preset_vars);
1690 }
1691 }
1692
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001693 srv->agent.inter = src->agent.inter;
1694 srv->agent.fastinter = src->agent.fastinter;
1695 srv->agent.downinter = src->agent.downinter;
1696 srv->maxqueue = src->maxqueue;
1697 srv->minconn = src->minconn;
1698 srv->maxconn = src->maxconn;
1699 srv->slowstart = src->slowstart;
1700 srv->observe = src->observe;
1701 srv->onerror = src->onerror;
1702 srv->onmarkeddown = src->onmarkeddown;
1703 srv->onmarkedup = src->onmarkedup;
1704 if (src->trackit != NULL)
1705 srv->trackit = strdup(src->trackit);
1706 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1707 srv->uweight = srv->iweight = src->iweight;
1708
1709 srv->check.send_proxy = src->check.send_proxy;
1710 /* health: up, but will fall down at first failure */
1711 srv->check.rise = srv->check.health = src->check.rise;
1712 srv->check.fall = src->check.fall;
1713
1714 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001715 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1716 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1717 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001718 srv->check.state |= CHK_ST_PAUSED;
1719 srv->check.health = 0;
1720 }
1721
1722 /* health: up but will fall down at first failure */
1723 srv->agent.rise = srv->agent.health = src->agent.rise;
1724 srv->agent.fall = src->agent.fall;
1725
1726 if (src->resolvers_id != NULL)
1727 srv->resolvers_id = strdup(src->resolvers_id);
1728 srv->dns_opts.family_prio = src->dns_opts.family_prio;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02001729 srv->dns_opts.accept_duplicate_ip = src->dns_opts.accept_duplicate_ip;
Daniel Corbettf8716912019-11-17 09:48:56 -05001730 srv->dns_opts.ignore_weight = src->dns_opts.ignore_weight;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001731 if (srv->dns_opts.family_prio == AF_UNSPEC)
1732 srv->dns_opts.family_prio = AF_INET6;
1733 memcpy(srv->dns_opts.pref_net,
1734 src->dns_opts.pref_net,
1735 sizeof srv->dns_opts.pref_net);
1736 srv->dns_opts.pref_net_nb = src->dns_opts.pref_net_nb;
1737
1738 srv->init_addr_methods = src->init_addr_methods;
1739 srv->init_addr = src->init_addr;
1740#if defined(USE_OPENSSL)
1741 srv_ssl_settings_cpy(srv, src);
1742#endif
1743#ifdef TCP_USER_TIMEOUT
1744 srv->tcp_ut = src->tcp_ut;
1745#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001746 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001747 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001748 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01001749 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01001750 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001751
Olivier Houchard8da5f982017-08-04 18:35:36 +02001752 if (srv_tmpl)
1753 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001754
1755 srv->check.via_socks4 = src->check.via_socks4;
1756 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001757}
1758
William Lallemand313bfd12018-10-26 14:47:32 +02001759struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001760{
1761 struct server *srv;
1762
1763 srv = calloc(1, sizeof *srv);
1764 if (!srv)
1765 return NULL;
1766
1767 srv->obj_type = OBJ_TYPE_SERVER;
1768 srv->proxy = proxy;
1769 LIST_INIT(&srv->actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04001770 srv->pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02001771
Emeric Brun52a91d32017-08-31 14:41:55 +02001772 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001773 srv->last_change = now.tv_sec;
1774
Christopher Faulet38290462020-04-21 11:46:40 +02001775 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001776 srv->check.status = HCHK_STATUS_INI;
1777 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01001778 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02001779 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001780
Christopher Faulet38290462020-04-21 11:46:40 +02001781 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001782 srv->agent.status = HCHK_STATUS_INI;
1783 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01001784 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001785 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
1786
Willy Tarreau975b1552019-06-06 16:25:55 +02001787 /* please don't put default server settings here, they are set in
1788 * init_default_instance().
1789 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001790 return srv;
1791}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001792
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001793#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1794static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
1795 struct server *srv, struct proxy *proxy)
1796{
1797 int ret;
1798 char *err = NULL;
1799
1800 if (!srv->sni_expr)
1801 return 0;
1802
1803 ret = server_parse_sni_expr(srv, proxy, &err);
1804 if (!ret)
1805 return 0;
1806
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001807 display_parser_err(file, linenum, args, cur_arg, ret, &err);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001808 free(err);
1809
1810 return ret;
1811}
1812#endif
1813
1814/*
1815 * Server initializations finalization.
1816 * Initialize health check, agent check and SNI expression if enabled.
1817 * Must not be called for a default server instance.
1818 */
1819static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
1820 struct server *srv, struct proxy *px)
1821{
Christopher Fauletb3b53522020-04-27 11:17:10 +02001822#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001823 int ret;
Christopher Fauletb3b53522020-04-27 11:17:10 +02001824#endif
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001825
Christopher Faulet8892e5d2020-03-26 19:48:20 +01001826 if (srv->do_check && srv->trackit) {
1827 ha_alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1828 file, linenum);
1829 return ERR_ALERT | ERR_FATAL;
1830 }
1831
1832 if (srv->do_agent && !srv->agent.port) {
1833 ha_alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
1834 file, linenum, srv->id);
1835 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001836 }
1837
1838#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1839 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
1840 return ret;
1841#endif
1842
1843 if (srv->flags & SRV_F_BACKUP)
1844 px->srv_bck++;
1845 else
1846 px->srv_act++;
1847 srv_lb_commit_status(srv);
1848
1849 return 0;
1850}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001851
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001852/*
1853 * Parse as much as possible such a range string argument: low[-high]
1854 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
1855 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
1856 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
1857 * Returns 0 if succeeded, -1 if not.
1858 */
1859static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
1860{
1861 char *nb_high_arg;
1862
1863 *nb_high = 0;
1864 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001865 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001866
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001867 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001868 *nb_high_arg++ = '\0';
1869 *nb_high = atoi(nb_high_arg);
1870 }
1871 else {
1872 *nb_high += *nb_low;
1873 *nb_low = 1;
1874 }
1875
1876 if (*nb_low < 0 || *nb_high < *nb_low)
1877 return -1;
1878
1879 return 0;
1880}
1881
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001882static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
1883{
1884 chunk_printf(&trash, "%s%d", prefix, nb);
1885 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001886 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001887}
1888
1889/*
1890 * Initialize as much as possible servers from <srv> server template.
1891 * Note that a server template is a special server with
1892 * a few different parameters than a server which has
1893 * been parsed mostly the same way as a server.
Joseph Herlant44466822018-11-15 08:57:51 -08001894 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001895 * 'srv' template included.
1896 */
1897static int server_template_init(struct server *srv, struct proxy *px)
1898{
1899 int i;
1900 struct server *newsrv;
1901
1902 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 +02001903 newsrv = new_server(px);
1904 if (!newsrv)
1905 goto err;
1906
1907 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001908 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001909#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1910 if (newsrv->sni_expr) {
1911 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
1912 if (!newsrv->ssl_ctx.sni)
1913 goto err;
1914 }
1915#endif
1916 /* Set this new server ID. */
1917 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
1918
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001919 /* Linked backwards first. This will be restablished after parsing. */
1920 newsrv->next = px->srv;
1921 px->srv = newsrv;
1922 }
1923 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1924
1925 return i - srv->tmpl_info.nb_low;
1926
1927 err:
1928 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1929 if (newsrv) {
1930#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1931 release_sample_expr(newsrv->ssl_ctx.sni);
1932#endif
1933 free_check(&newsrv->agent);
1934 free_check(&newsrv->check);
1935 }
1936 free(newsrv);
1937 return i - srv->tmpl_info.nb_low;
1938}
1939
Emeric Brund3db3842020-07-21 16:54:36 +02001940int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy,
1941 struct proxy *defproxy, int parse_addr, int in_peers_section, int initial_resolve)
Willy Tarreau272adea2014-03-31 10:39:59 +02001942{
1943 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001944 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001945 char *errmsg = NULL;
1946 int err_code = 0;
1947 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02001948 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001949
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001950 if (!strcmp(args[0], "server") ||
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02001951 !strcmp(args[0], "peer") ||
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001952 !strcmp(args[0], "default-server") ||
1953 !strcmp(args[0], "server-template")) {
Willy Tarreau272adea2014-03-31 10:39:59 +02001954 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001955 int defsrv = (*args[0] == 'd');
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02001956 int srv = !defsrv && (*args[0] == 'p' || !strcmp(args[0], "server"));
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001957 int srv_tmpl = !defsrv && !srv;
1958 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02001959
1960 if (!defsrv && curproxy == defproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001961 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001962 err_code |= ERR_ALERT | ERR_FATAL;
1963 goto out;
1964 }
1965 else if (warnifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL))
Olivier Houchard306e6532018-07-24 16:48:59 +02001966 err_code |= ERR_WARN;
Willy Tarreau272adea2014-03-31 10:39:59 +02001967
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001968 /* There is no mandatory first arguments for default server. */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01001969 if (srv && parse_addr) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001970 if (!*args[2]) {
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +02001971 if (in_peers_section) {
1972 return 0;
1973 }
1974 else {
1975 /* 'server' line number of argument check. */
1976 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1977 file, linenum, args[0]);
1978 err_code |= ERR_ALERT | ERR_FATAL;
1979 goto out;
1980 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001981 }
1982
1983 err = invalid_char(args[1]);
1984 }
1985 else if (srv_tmpl) {
1986 if (!*args[3]) {
1987 /* 'server-template' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001988 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 +02001989 file, linenum, args[0]);
1990 err_code |= ERR_ALERT | ERR_FATAL;
1991 goto out;
1992 }
1993
1994 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001995 }
1996
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001997 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001998 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 +02001999 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002000 err_code |= ERR_ALERT | ERR_FATAL;
2001 goto out;
2002 }
2003
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002004 cur_arg = 2;
2005 if (srv_tmpl) {
2006 /* Parse server-template <nb | range> arg. */
2007 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002008 ha_alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002009 file, linenum, args[0], args[cur_arg]);
2010 err_code |= ERR_ALERT | ERR_FATAL;
2011 goto out;
2012 }
2013 cur_arg++;
2014 }
2015
Willy Tarreau272adea2014-03-31 10:39:59 +02002016 if (!defsrv) {
2017 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002018 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002019 struct protocol *proto;
2020
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002021 newsrv = new_server(curproxy);
2022 if (!newsrv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002023 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Willy Tarreau272adea2014-03-31 10:39:59 +02002024 err_code |= ERR_ALERT | ERR_ABORT;
2025 goto out;
2026 }
2027
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002028 if (srv_tmpl) {
2029 newsrv->tmpl_info.nb_low = tmpl_range_low;
2030 newsrv->tmpl_info.nb_high = tmpl_range_high;
2031 }
2032
Willy Tarreau272adea2014-03-31 10:39:59 +02002033 /* the servers are linked backwards first */
2034 newsrv->next = curproxy->srv;
2035 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02002036 newsrv->conf.file = strdup(file);
2037 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002038 /* Note: for a server template, its id is its prefix.
2039 * This is a temporary id which will be used for server allocations to come
2040 * after parsing.
2041 */
2042 if (srv)
2043 newsrv->id = strdup(args[1]);
2044 else
2045 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002046
2047 /* several ways to check the port component :
2048 * - IP => port=+0, relative (IPv4 only)
2049 * - IP: => port=+0, relative
2050 * - IP:N => port=N, absolute
2051 * - IP:+N => port=+N, relative
2052 * - IP:-N => port=-N, relative
2053 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002054 if (!parse_addr)
2055 goto skip_addr;
2056
Emeric Brund3db3842020-07-21 16:54:36 +02002057 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, &errmsg, NULL, &fqdn, initial_resolve);
Willy Tarreau272adea2014-03-31 10:39:59 +02002058 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002059 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau272adea2014-03-31 10:39:59 +02002060 err_code |= ERR_ALERT | ERR_FATAL;
2061 goto out;
2062 }
2063
2064 proto = protocol_by_family(sk->ss_family);
Willy Tarreau9698f4b2017-01-06 18:42:57 +01002065 if (!fqdn && (!proto || !proto->connect)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002066 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002067 file, linenum, args[0], args[1]);
2068 err_code |= ERR_ALERT | ERR_FATAL;
2069 goto out;
2070 }
2071
2072 if (!port1 || !port2) {
2073 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002074 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002075 }
2076 else if (port1 != port2) {
2077 /* port range */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002078 ha_alert("parsing [%s:%d] : '%s %s' : port ranges are not allowed in '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002079 file, linenum, args[0], args[1], args[2]);
2080 err_code |= ERR_ALERT | ERR_FATAL;
2081 goto out;
2082 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002083
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002084 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002085 if (fqdn) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002086 if (fqdn[0] == '_') { /* SRV record */
Olivier Houchard8da5f982017-08-04 18:35:36 +02002087 /* Check if a SRV request already exists, and if not, create it */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002088 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
2089 newsrv->srvrq = new_dns_srvrq(newsrv, fqdn);
2090 if (newsrv->srvrq == NULL) {
Olivier Houchard8da5f982017-08-04 18:35:36 +02002091 err_code |= ERR_ALERT | ERR_FATAL;
2092 goto out;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002093 }
2094 }
2095 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002096 ha_alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
Christopher Faulet67957bd2017-09-27 11:00:59 +02002097 file, linenum, newsrv->id);
2098 err_code |= ERR_ALERT | ERR_FATAL;
2099 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002100 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002101 }
2102
Willy Tarreau272adea2014-03-31 10:39:59 +02002103 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002104 newsrv->svc_port = port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002105
Olivier Houchard8da5f982017-08-04 18:35:36 +02002106 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002107 ha_alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002108 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002109 err_code |= ERR_ALERT | ERR_FATAL;
2110 goto out;
2111 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002112
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002113 cur_arg++;
2114 skip_addr:
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002115 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002116 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002117 HA_SPIN_INIT(&newsrv->lock);
Willy Tarreau272adea2014-03-31 10:39:59 +02002118 } else {
2119 newsrv = &curproxy->defsrv;
2120 cur_arg = 1;
Thierry Fournierada34842016-02-17 21:25:09 +01002121 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002122 newsrv->dns_opts.accept_duplicate_ip = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002123 }
2124
2125 while (*args[cur_arg]) {
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002126 if (!strcmp(args[cur_arg], "init-addr")) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002127 char *p, *end;
2128 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002129 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002130
2131 newsrv->init_addr_methods = 0;
2132 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2133
2134 for (p = args[cur_arg + 1]; *p; p = end) {
2135 /* cut on next comma */
2136 for (end = p; *end && *end != ','; end++);
2137 if (*end)
2138 *(end++) = 0;
2139
Willy Tarreau4310d362016-11-02 15:05:56 +01002140 memset(&sa, 0, sizeof(sa));
Baptiste Assmann25938272016-09-21 20:26:16 +02002141 if (!strcmp(p, "libc")) {
2142 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2143 }
2144 else if (!strcmp(p, "last")) {
2145 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2146 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01002147 else if (!strcmp(p, "none")) {
2148 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2149 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002150 else if (str2ip2(p, &sa, 0)) {
2151 if (is_addr(&newsrv->init_addr)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002152 ha_alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
Willy Tarreau4310d362016-11-02 15:05:56 +01002153 file, linenum, args[cur_arg], p);
2154 err_code |= ERR_ALERT | ERR_FATAL;
2155 goto out;
2156 }
2157 newsrv->init_addr = sa;
2158 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2159 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002160 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002161 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 +02002162 file, linenum, args[cur_arg], p);
2163 err_code |= ERR_ALERT | ERR_FATAL;
2164 goto out;
2165 }
2166 if (!done) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002167 ha_alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002168 file, linenum, args[cur_arg], p);
2169 err_code |= ERR_ALERT | ERR_FATAL;
2170 goto out;
2171 }
2172 }
2173 cur_arg += 2;
2174 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002175 else if (!strcmp(args[cur_arg], "resolvers")) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002176 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002177 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2178 cur_arg += 2;
2179 }
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002180 else if (!strcmp(args[cur_arg], "resolve-opts")) {
2181 char *p, *end;
2182
2183 for (p = args[cur_arg + 1]; *p; p = end) {
2184 /* cut on next comma */
2185 for (end = p; *end && *end != ','; end++);
2186 if (*end)
2187 *(end++) = 0;
2188
2189 if (!strcmp(p, "allow-dup-ip")) {
2190 newsrv->dns_opts.accept_duplicate_ip = 1;
2191 }
Daniel Corbettf8716912019-11-17 09:48:56 -05002192 else if (!strcmp(p, "ignore-weight")) {
2193 newsrv->dns_opts.ignore_weight = 1;
2194 }
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002195 else if (!strcmp(p, "prevent-dup-ip")) {
2196 newsrv->dns_opts.accept_duplicate_ip = 0;
2197 }
2198 else {
Daniel Corbettf8716912019-11-17 09:48:56 -05002199 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 +02002200 file, linenum, args[cur_arg], p);
2201 err_code |= ERR_ALERT | ERR_FATAL;
2202 goto out;
2203 }
2204 }
2205
2206 cur_arg += 2;
2207 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002208 else if (!strcmp(args[cur_arg], "resolve-prefer")) {
2209 if (!strcmp(args[cur_arg + 1], "ipv4"))
Thierry Fournierada34842016-02-17 21:25:09 +01002210 newsrv->dns_opts.family_prio = AF_INET;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002211 else if (!strcmp(args[cur_arg + 1], "ipv6"))
Thierry Fournierada34842016-02-17 21:25:09 +01002212 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002213 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002214 ha_alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002215 file, linenum, args[cur_arg]);
2216 err_code |= ERR_ALERT | ERR_FATAL;
2217 goto out;
2218 }
2219 cur_arg += 2;
2220 }
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002221 else if (!strcmp(args[cur_arg], "resolve-net")) {
2222 char *p, *e;
2223 unsigned char mask;
2224 struct dns_options *opt;
2225
2226 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002227 ha_alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002228 file, linenum, args[cur_arg]);
2229 err_code |= ERR_ALERT | ERR_FATAL;
2230 goto out;
2231 }
2232
2233 opt = &newsrv->dns_opts;
2234
2235 /* Split arguments by comma, and convert it from ipv4 or ipv6
2236 * string network in in_addr or in6_addr.
2237 */
2238 p = args[cur_arg + 1];
2239 e = p;
2240 while (*p != '\0') {
Joseph Herlant44466822018-11-15 08:57:51 -08002241 /* If no room available, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002242 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002243 ha_alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002244 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2245 err_code |= ERR_ALERT | ERR_FATAL;
2246 goto out;
2247 }
2248 /* look for end or comma. */
2249 while (*e != ',' && *e != '\0')
2250 e++;
2251 if (*e == ',') {
2252 *e = '\0';
2253 e++;
2254 }
2255 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2256 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2257 /* Try to convert input string from ipv4 or ipv6 network. */
2258 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2259 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2260 &mask)) {
2261 /* Try to convert input string from ipv6 network. */
2262 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2263 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2264 } else {
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002265 /* All network conversions fail, return error. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002266 ha_alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002267 file, linenum, args[cur_arg], p);
2268 err_code |= ERR_ALERT | ERR_FATAL;
2269 goto out;
2270 }
2271 opt->pref_net_nb++;
2272 p = e;
2273 }
2274
2275 cur_arg += 2;
2276 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002277 else if (!strcmp(args[cur_arg], "weight")) {
2278 int w;
2279 w = atol(args[cur_arg + 1]);
2280 if (w < 0 || w > SRV_UWGHT_MAX) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002281 ha_alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002282 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2283 err_code |= ERR_ALERT | ERR_FATAL;
2284 goto out;
2285 }
2286 newsrv->uweight = newsrv->iweight = w;
2287 cur_arg += 2;
2288 }
Emeric Brun97556472020-05-30 01:42:45 +02002289 else if (!strcmp(args[cur_arg], "log-proto")) {
2290 if (!strcmp(args[cur_arg + 1], "legacy"))
2291 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
2292 else if (!strcmp(args[cur_arg + 1], "octet-count"))
2293 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
2294 else {
2295 ha_alert("parsing [%s:%d]: '%s' expects one of 'legacy' or "
2296 "'octet-count' but got '%s'\n",
2297 file, linenum, args[cur_arg], args[cur_arg + 1]);
2298 err_code |= ERR_ALERT | ERR_FATAL;
2299 goto out;
2300 }
2301 cur_arg += 2;
2302 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002303 else if (!strcmp(args[cur_arg], "minconn")) {
2304 newsrv->minconn = atol(args[cur_arg + 1]);
2305 cur_arg += 2;
2306 }
2307 else if (!strcmp(args[cur_arg], "maxconn")) {
2308 newsrv->maxconn = atol(args[cur_arg + 1]);
2309 cur_arg += 2;
2310 }
2311 else if (!strcmp(args[cur_arg], "maxqueue")) {
2312 newsrv->maxqueue = atol(args[cur_arg + 1]);
2313 cur_arg += 2;
2314 }
2315 else if (!strcmp(args[cur_arg], "slowstart")) {
2316 /* slowstart is stored in seconds */
2317 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02002318
2319 if (err == PARSE_TIME_OVER) {
2320 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).\n",
2321 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2322 err_code |= ERR_ALERT | ERR_FATAL;
2323 goto out;
2324 }
2325 else if (err == PARSE_TIME_UNDER) {
2326 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.\n",
2327 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2328 err_code |= ERR_ALERT | ERR_FATAL;
2329 goto out;
2330 }
2331 else if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002332 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002333 file, linenum, *err, newsrv->id);
2334 err_code |= ERR_ALERT | ERR_FATAL;
2335 goto out;
2336 }
2337 newsrv->slowstart = (val + 999) / 1000;
2338 cur_arg += 2;
2339 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002340 else if (!strcmp(args[cur_arg], "on-error")) {
2341 if (!strcmp(args[cur_arg + 1], "fastinter"))
2342 newsrv->onerror = HANA_ONERR_FASTINTER;
2343 else if (!strcmp(args[cur_arg + 1], "fail-check"))
2344 newsrv->onerror = HANA_ONERR_FAILCHK;
2345 else if (!strcmp(args[cur_arg + 1], "sudden-death"))
2346 newsrv->onerror = HANA_ONERR_SUDDTH;
2347 else if (!strcmp(args[cur_arg + 1], "mark-down"))
2348 newsrv->onerror = HANA_ONERR_MARKDWN;
2349 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002350 ha_alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
Willy Tarreau272adea2014-03-31 10:39:59 +02002351 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2352 file, linenum, args[cur_arg], args[cur_arg + 1]);
2353 err_code |= ERR_ALERT | ERR_FATAL;
2354 goto out;
2355 }
2356
2357 cur_arg += 2;
2358 }
2359 else if (!strcmp(args[cur_arg], "on-marked-down")) {
2360 if (!strcmp(args[cur_arg + 1], "shutdown-sessions"))
2361 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2362 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002363 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002364 file, linenum, args[cur_arg], args[cur_arg + 1]);
2365 err_code |= ERR_ALERT | ERR_FATAL;
2366 goto out;
2367 }
2368
2369 cur_arg += 2;
2370 }
2371 else if (!strcmp(args[cur_arg], "on-marked-up")) {
2372 if (!strcmp(args[cur_arg + 1], "shutdown-backup-sessions"))
2373 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2374 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002375 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002376 file, linenum, args[cur_arg], args[cur_arg + 1]);
2377 err_code |= ERR_ALERT | ERR_FATAL;
2378 goto out;
2379 }
2380
2381 cur_arg += 2;
2382 }
2383 else if (!strcmp(args[cur_arg], "error-limit")) {
2384 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002385 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002386 file, linenum, args[cur_arg]);
2387 err_code |= ERR_ALERT | ERR_FATAL;
2388 goto out;
2389 }
2390
2391 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2392
2393 if (newsrv->consecutive_errors_limit <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002394 ha_alert("parsing [%s:%d]: %s has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002395 file, linenum, args[cur_arg]);
2396 err_code |= ERR_ALERT | ERR_FATAL;
2397 goto out;
2398 }
2399 cur_arg += 2;
2400 }
Frédéric Lécaille8d083ed2017-04-14 15:19:56 +02002401 else if (!strcmp(args[cur_arg], "usesrc")) { /* address to use outside: needs "source" first */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002402 ha_alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002403 file, linenum, "usesrc", "source");
2404 err_code |= ERR_ALERT | ERR_FATAL;
2405 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002406 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002407 else {
2408 static int srv_dumped;
2409 struct srv_kw *kw;
2410 char *err;
2411
2412 kw = srv_find_kw(args[cur_arg]);
2413 if (kw) {
2414 char *err = NULL;
2415 int code;
2416
2417 if (!kw->parse) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002418 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 +02002419 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002420 if (kw->skip != -1)
2421 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002422 err_code |= ERR_ALERT | ERR_FATAL;
2423 goto out;
2424 }
2425
2426 if (defsrv && !kw->default_ok) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002427 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002428 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002429 if (kw->skip != -1)
2430 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002431 err_code |= ERR_ALERT;
2432 continue;
2433 }
2434
2435 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2436 err_code |= code;
2437
2438 if (code) {
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002439 display_parser_err(file, linenum, args, cur_arg, code, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002440 if (code & ERR_FATAL) {
2441 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002442 if (kw->skip != -1)
2443 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002444 goto out;
2445 }
2446 }
2447 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002448 if (kw->skip != -1)
2449 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002450 continue;
2451 }
2452
2453 err = NULL;
2454 if (!srv_dumped) {
2455 srv_dump_kws(&err);
2456 indent_msg(&err, 4);
2457 srv_dumped = 1;
2458 }
2459
Christopher Faulet767a84b2017-11-24 16:50:31 +01002460 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002461 file, linenum, args[0], args[1], args[cur_arg],
2462 err ? " Registered keywords :" : "", err ? err : "");
2463 free(err);
2464
2465 err_code |= ERR_ALERT | ERR_FATAL;
2466 goto out;
2467 }
2468 }
2469
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002470 if (!defsrv)
2471 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2472 if (err_code & ERR_FATAL)
2473 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002474 if (srv_tmpl)
2475 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002476 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002477 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002478 return 0;
2479
2480 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002481 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002482 free(errmsg);
2483 return err_code;
2484}
2485
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002486/* Returns a pointer to the first server matching either id <id>.
2487 * NULL is returned if no match is found.
2488 * the lookup is performed in the backend <bk>
2489 */
2490struct server *server_find_by_id(struct proxy *bk, int id)
2491{
2492 struct eb32_node *eb32;
2493 struct server *curserver;
2494
2495 if (!bk || (id ==0))
2496 return NULL;
2497
2498 /* <bk> has no backend capabilities, so it can't have a server */
2499 if (!(bk->cap & PR_CAP_BE))
2500 return NULL;
2501
2502 curserver = NULL;
2503
2504 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2505 if (eb32)
2506 curserver = container_of(eb32, struct server, conf.id);
2507
2508 return curserver;
2509}
2510
2511/* Returns a pointer to the first server matching either name <name>, or id
2512 * if <name> starts with a '#'. NULL is returned if no match is found.
2513 * the lookup is performed in the backend <bk>
2514 */
2515struct server *server_find_by_name(struct proxy *bk, const char *name)
2516{
2517 struct server *curserver;
2518
2519 if (!bk || !name)
2520 return NULL;
2521
2522 /* <bk> has no backend capabilities, so it can't have a server */
2523 if (!(bk->cap & PR_CAP_BE))
2524 return NULL;
2525
2526 curserver = NULL;
2527 if (*name == '#') {
2528 curserver = server_find_by_id(bk, atoi(name + 1));
2529 if (curserver)
2530 return curserver;
2531 }
2532 else {
2533 curserver = bk->srv;
2534
2535 while (curserver && (strcmp(curserver->id, name) != 0))
2536 curserver = curserver->next;
2537
2538 if (curserver)
2539 return curserver;
2540 }
2541
2542 return NULL;
2543}
2544
2545struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2546{
2547 struct server *byname;
2548 struct server *byid;
2549
2550 if (!name && !id)
2551 return NULL;
2552
2553 if (diff)
2554 *diff = 0;
2555
2556 byname = byid = NULL;
2557
2558 if (name) {
2559 byname = server_find_by_name(bk, name);
2560 if (byname && (!id || byname->puid == id))
2561 return byname;
2562 }
2563
2564 /* remaining possibilities :
2565 * - name not set
2566 * - name set but not found
2567 * - name found but ID doesn't match
2568 */
2569 if (id) {
2570 byid = server_find_by_id(bk, id);
2571 if (byid) {
2572 if (byname) {
2573 /* use id only if forced by configuration */
2574 if (byid->flags & SRV_F_FORCED_ID) {
2575 if (diff)
2576 *diff |= 2;
2577 return byid;
2578 }
2579 else {
2580 if (diff)
2581 *diff |= 1;
2582 return byname;
2583 }
2584 }
2585
2586 /* remaining possibilities:
2587 * - name not set
2588 * - name set but not found
2589 */
2590 if (name && diff)
2591 *diff |= 2;
2592 return byid;
2593 }
2594
2595 /* id bot found */
2596 if (byname) {
2597 if (diff)
2598 *diff |= 1;
2599 return byname;
2600 }
2601 }
2602
2603 return NULL;
2604}
2605
Willy Tarreau46b7f532018-08-21 11:54:26 +02002606/* Update a server state using the parameters available in the params list.
2607 *
2608 * Grabs the server lock during operation.
2609 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002610static void srv_update_state(struct server *srv, int version, char **params)
2611{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002612 char *p;
Willy Tarreau83061a82018-07-13 11:56:34 +02002613 struct buffer *msg;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002614
2615 /* fields since version 1
2616 * and common to all other upcoming versions
2617 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002618 enum srv_state srv_op_state;
2619 enum srv_admin srv_admin_state;
2620 unsigned srv_uweight, srv_iweight;
2621 unsigned long srv_last_time_change;
2622 short srv_check_status;
2623 enum chk_result srv_check_result;
2624 int srv_check_health;
2625 int srv_check_state, srv_agent_state;
2626 int bk_f_forced_id;
2627 int srv_f_forced_id;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002628 int fqdn_set_by_cli;
2629 const char *fqdn;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002630 const char *port_str;
2631 unsigned int port;
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002632 char *srvrecord;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002633
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002634 fqdn = NULL;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002635 port = 0;
Willy Tarreau31138fa2015-09-29 18:38:47 +02002636 msg = get_trash_chunk();
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002637 switch (version) {
2638 case 1:
2639 /*
2640 * now we can proceed with server's state update:
2641 * srv_addr: params[0]
2642 * srv_op_state: params[1]
2643 * srv_admin_state: params[2]
2644 * srv_uweight: params[3]
2645 * srv_iweight: params[4]
2646 * srv_last_time_change: params[5]
2647 * srv_check_status: params[6]
2648 * srv_check_result: params[7]
2649 * srv_check_health: params[8]
2650 * srv_check_state: params[9]
2651 * srv_agent_state: params[10]
2652 * bk_f_forced_id: params[11]
2653 * srv_f_forced_id: params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002654 * srv_fqdn: params[13]
Frédéric Lécaille31694712017-08-01 08:47:19 +02002655 * srv_port: params[14]
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002656 * srvrecord: params[15]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002657 */
2658
2659 /* validating srv_op_state */
2660 p = NULL;
2661 errno = 0;
2662 srv_op_state = strtol(params[1], &p, 10);
2663 if ((p == params[1]) || errno == EINVAL || errno == ERANGE ||
2664 (srv_op_state != SRV_ST_STOPPED &&
2665 srv_op_state != SRV_ST_STARTING &&
2666 srv_op_state != SRV_ST_RUNNING &&
2667 srv_op_state != SRV_ST_STOPPING)) {
2668 chunk_appendf(msg, ", invalid srv_op_state value '%s'", params[1]);
2669 }
2670
2671 /* validating srv_admin_state */
2672 p = NULL;
2673 errno = 0;
2674 srv_admin_state = strtol(params[2], &p, 10);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002675 fqdn_set_by_cli = !!(srv_admin_state & SRV_ADMF_HMAINT);
Willy Tarreau757478e2016-11-03 19:22:19 +01002676
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002677 /* inherited statuses will be recomputed later.
2678 * Also disable SRV_ADMF_HMAINT flag (set from stats socket fqdn).
2679 */
2680 srv_admin_state &= ~SRV_ADMF_IDRAIN & ~SRV_ADMF_IMAINT & ~SRV_ADMF_HMAINT;
Willy Tarreau757478e2016-11-03 19:22:19 +01002681
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002682 if ((p == params[2]) || errno == EINVAL || errno == ERANGE ||
2683 (srv_admin_state != 0 &&
2684 srv_admin_state != SRV_ADMF_FMAINT &&
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002685 srv_admin_state != SRV_ADMF_CMAINT &&
2686 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT) &&
Willy Tarreaue1bde142016-11-03 18:33:25 +01002687 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FDRAIN) &&
Willy Tarreau757478e2016-11-03 19:22:19 +01002688 srv_admin_state != SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002689 chunk_appendf(msg, ", invalid srv_admin_state value '%s'", params[2]);
2690 }
2691
2692 /* validating srv_uweight */
2693 p = NULL;
2694 errno = 0;
2695 srv_uweight = strtol(params[3], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002696 if ((p == params[3]) || errno == EINVAL || errno == ERANGE || (srv_uweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002697 chunk_appendf(msg, ", invalid srv_uweight value '%s'", params[3]);
2698
2699 /* validating srv_iweight */
2700 p = NULL;
2701 errno = 0;
2702 srv_iweight = strtol(params[4], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002703 if ((p == params[4]) || errno == EINVAL || errno == ERANGE || (srv_iweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002704 chunk_appendf(msg, ", invalid srv_iweight value '%s'", params[4]);
2705
2706 /* validating srv_last_time_change */
2707 p = NULL;
2708 errno = 0;
2709 srv_last_time_change = strtol(params[5], &p, 10);
2710 if ((p == params[5]) || errno == EINVAL || errno == ERANGE)
2711 chunk_appendf(msg, ", invalid srv_last_time_change value '%s'", params[5]);
2712
2713 /* validating srv_check_status */
2714 p = NULL;
2715 errno = 0;
2716 srv_check_status = strtol(params[6], &p, 10);
2717 if (p == params[6] || errno == EINVAL || errno == ERANGE ||
2718 (srv_check_status >= HCHK_STATUS_SIZE))
2719 chunk_appendf(msg, ", invalid srv_check_status value '%s'", params[6]);
2720
2721 /* validating srv_check_result */
2722 p = NULL;
2723 errno = 0;
2724 srv_check_result = strtol(params[7], &p, 10);
2725 if ((p == params[7]) || errno == EINVAL || errno == ERANGE ||
2726 (srv_check_result != CHK_RES_UNKNOWN &&
2727 srv_check_result != CHK_RES_NEUTRAL &&
2728 srv_check_result != CHK_RES_FAILED &&
2729 srv_check_result != CHK_RES_PASSED &&
2730 srv_check_result != CHK_RES_CONDPASS)) {
2731 chunk_appendf(msg, ", invalid srv_check_result value '%s'", params[7]);
2732 }
2733
2734 /* validating srv_check_health */
2735 p = NULL;
2736 errno = 0;
2737 srv_check_health = strtol(params[8], &p, 10);
2738 if (p == params[8] || errno == EINVAL || errno == ERANGE)
2739 chunk_appendf(msg, ", invalid srv_check_health value '%s'", params[8]);
2740
2741 /* validating srv_check_state */
2742 p = NULL;
2743 errno = 0;
2744 srv_check_state = strtol(params[9], &p, 10);
2745 if (p == params[9] || errno == EINVAL || errno == ERANGE ||
2746 (srv_check_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2747 chunk_appendf(msg, ", invalid srv_check_state value '%s'", params[9]);
2748
2749 /* validating srv_agent_state */
2750 p = NULL;
2751 errno = 0;
2752 srv_agent_state = strtol(params[10], &p, 10);
2753 if (p == params[10] || errno == EINVAL || errno == ERANGE ||
2754 (srv_agent_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2755 chunk_appendf(msg, ", invalid srv_agent_state value '%s'", params[10]);
2756
2757 /* validating bk_f_forced_id */
2758 p = NULL;
2759 errno = 0;
2760 bk_f_forced_id = strtol(params[11], &p, 10);
2761 if (p == params[11] || errno == EINVAL || errno == ERANGE || !((bk_f_forced_id == 0) || (bk_f_forced_id == 1)))
2762 chunk_appendf(msg, ", invalid bk_f_forced_id value '%s'", params[11]);
2763
2764 /* validating srv_f_forced_id */
2765 p = NULL;
2766 errno = 0;
2767 srv_f_forced_id = strtol(params[12], &p, 10);
2768 if (p == params[12] || errno == EINVAL || errno == ERANGE || !((srv_f_forced_id == 0) || (srv_f_forced_id == 1)))
2769 chunk_appendf(msg, ", invalid srv_f_forced_id value '%s'", params[12]);
2770
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002771 /* validating srv_fqdn */
2772 fqdn = params[13];
2773 if (fqdn && *fqdn == '-')
2774 fqdn = NULL;
2775 if (fqdn && (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn))) {
2776 chunk_appendf(msg, ", invalid srv_fqdn value '%s'", params[13]);
2777 fqdn = NULL;
2778 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002779
Frédéric Lécaille31694712017-08-01 08:47:19 +02002780 port_str = params[14];
2781 if (port_str) {
2782 port = strl2uic(port_str, strlen(port_str));
2783 if (port > USHRT_MAX) {
2784 chunk_appendf(msg, ", invalid srv_port value '%s'", port_str);
2785 port_str = NULL;
2786 }
2787 }
2788
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002789 /* SRV record
2790 * NOTE: in HAProxy, SRV records must start with an underscore '_'
2791 */
2792 srvrecord = params[15];
2793 if (srvrecord && *srvrecord != '_')
2794 srvrecord = NULL;
2795
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002796 /* don't apply anything if one error has been detected */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002797 if (msg->data)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002798 goto out;
2799
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002800 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002801 /* recover operational state and apply it to this server
2802 * and all servers tracking this one */
Jérôme Magninf57afa42019-01-20 11:27:40 +01002803 srv->check.health = srv_check_health;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002804 switch (srv_op_state) {
2805 case SRV_ST_STOPPED:
2806 srv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02002807 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002808 break;
2809 case SRV_ST_STARTING:
Jérôme Magninf57afa42019-01-20 11:27:40 +01002810 /* If rise == 1 there is no STARTING state, let's switch to
2811 * RUNNING
2812 */
2813 if (srv->check.rise == 1) {
2814 srv->check.health = srv->check.rise + srv->check.fall - 1;
2815 srv_set_running(srv, "", NULL);
2816 break;
2817 }
2818 if (srv->check.health < 1 || srv->check.health >= srv->check.rise)
2819 srv->check.health = srv->check.rise - 1;
Emeric Brun52a91d32017-08-31 14:41:55 +02002820 srv->next_state = srv_op_state;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002821 break;
2822 case SRV_ST_STOPPING:
Jérôme Magninf57afa42019-01-20 11:27:40 +01002823 /* If fall == 1 there is no STOPPING state, let's switch to
2824 * STOPPED
2825 */
2826 if (srv->check.fall == 1) {
2827 srv->check.health = 0;
2828 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
2829 break;
2830 }
2831 if (srv->check.health < srv->check.rise ||
2832 srv->check.health > srv->check.rise + srv->check.fall - 2)
2833 srv->check.health = srv->check.rise;
Emeric Brun5a133512017-10-19 14:42:30 +02002834 srv_set_stopping(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002835 break;
2836 case SRV_ST_RUNNING:
2837 srv->check.health = srv->check.rise + srv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02002838 srv_set_running(srv, "", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002839 break;
2840 }
2841
2842 /* When applying server state, the following rules apply:
2843 * - in case of a configuration change, we apply the setting from the new
2844 * configuration, regardless of old running state
2845 * - if no configuration change, we apply old running state only if old running
2846 * state is different from new configuration state
2847 */
2848 /* configuration has changed */
Emeric Brun52a91d32017-08-31 14:41:55 +02002849 if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->next_admin & SRV_ADMF_CMAINT)) {
2850 if (srv->next_admin & SRV_ADMF_CMAINT)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002851 srv_adm_set_maint(srv);
2852 else
2853 srv_adm_set_ready(srv);
2854 }
2855 /* configuration is the same, let's compate old running state and new conf state */
2856 else {
Emeric Brun52a91d32017-08-31 14:41:55 +02002857 if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002858 srv_adm_set_maint(srv);
Emeric Brun52a91d32017-08-31 14:41:55 +02002859 else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002860 srv_adm_set_ready(srv);
2861 }
2862 /* apply drain mode if server is currently enabled */
Emeric Brun52a91d32017-08-31 14:41:55 +02002863 if (!(srv->next_admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002864 /* The SRV_ADMF_FDRAIN flag is inherited when srv->iweight is 0
Willy Tarreau22cace22016-11-03 18:19:49 +01002865 * (srv->iweight is the weight set up in configuration).
2866 * There are two possible reasons for FDRAIN to have been present :
2867 * - previous config weight was zero
2868 * - "set server b/s drain" was sent to the CLI
2869 *
2870 * In the first case, we simply want to drop this drain state
2871 * if the new weight is not zero anymore, meaning the administrator
2872 * has intentionally turned the weight back to a positive value to
2873 * enable the server again after an operation. In the second case,
2874 * the drain state was forced on the CLI regardless of the config's
2875 * weight so we don't want a change to the config weight to lose this
2876 * status. What this means is :
2877 * - if previous weight was 0 and new one is >0, drop the DRAIN state.
2878 * - if the previous weight was >0, keep it.
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002879 */
Willy Tarreau22cace22016-11-03 18:19:49 +01002880 if (srv_iweight > 0 || srv->iweight == 0)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002881 srv_adm_set_drain(srv);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002882 }
2883
2884 srv->last_change = date.tv_sec - srv_last_time_change;
2885 srv->check.status = srv_check_status;
2886 srv->check.result = srv_check_result;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002887
2888 /* Only case we want to apply is removing ENABLED flag which could have been
2889 * done by the "disable health" command over the stats socket
2890 */
2891 if ((srv->check.state & CHK_ST_CONFIGURED) &&
2892 (srv_check_state & CHK_ST_CONFIGURED) &&
2893 !(srv_check_state & CHK_ST_ENABLED))
2894 srv->check.state &= ~CHK_ST_ENABLED;
2895
2896 /* Only case we want to apply is removing ENABLED flag which could have been
2897 * done by the "disable agent" command over the stats socket
2898 */
2899 if ((srv->agent.state & CHK_ST_CONFIGURED) &&
2900 (srv_agent_state & CHK_ST_CONFIGURED) &&
2901 !(srv_agent_state & CHK_ST_ENABLED))
2902 srv->agent.state &= ~CHK_ST_ENABLED;
2903
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002904 /* We want to apply the previous 'running' weight (srv_uweight) only if there
2905 * was no change in the configuration: both previous and new iweight are equals
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002906 *
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002907 * It means that a configuration file change has precedence over a unix socket change
2908 * for server's weight
2909 *
2910 * by default, HAProxy applies the following weight when parsing the configuration
2911 * srv->uweight = srv->iweight
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002912 */
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002913 if (srv_iweight == srv->iweight) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002914 srv->uweight = srv_uweight;
2915 }
Willy Tarreau3ff577e2018-08-02 11:48:52 +02002916 server_recalc_eweight(srv, 1);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002917
Willy Tarreaue5a60682016-11-09 14:54:53 +01002918 /* load server IP address */
Daniel Corbett9215ffa2018-05-19 19:43:24 -04002919 if (strcmp(params[0], "-"))
2920 srv->lastaddr = strdup(params[0]);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002921
2922 if (fqdn && srv->hostname) {
2923 if (!strcmp(srv->hostname, fqdn)) {
2924 /* Here we reset the 'set from stats socket FQDN' flag
2925 * to support such transitions:
2926 * Let's say initial FQDN value is foo1 (in configuration file).
2927 * - FQDN changed from stats socket, from foo1 to foo2 value,
2928 * - FQDN changed again from file configuration (with the same previous value
2929 set from stats socket, from foo1 to foo2 value),
2930 * - reload for any other reason than a FQDN modification,
2931 * the configuration file FQDN matches the fqdn server state file value.
2932 * So we must reset the 'set from stats socket FQDN' flag to be consistent with
Joseph Herlant44466822018-11-15 08:57:51 -08002933 * any further FQDN modification.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002934 */
Emeric Brun52a91d32017-08-31 14:41:55 +02002935 srv->next_admin &= ~SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002936 }
2937 else {
2938 /* If the FDQN has been changed from stats socket,
2939 * apply fqdn state file value (which is the value set
2940 * from stats socket).
Baptiste Assmann13a92322019-06-07 09:40:55 +02002941 * Also ensure the runtime resolver will process this resolution.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002942 */
2943 if (fqdn_set_by_cli) {
Olivier Houchardd16bfe62017-10-31 15:21:19 +01002944 srv_set_fqdn(srv, fqdn, 0);
Baptiste Assmann13a92322019-06-07 09:40:55 +02002945 srv->flags &= ~SRV_F_NO_RESOLUTION;
Emeric Brun52a91d32017-08-31 14:41:55 +02002946 srv->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002947 }
2948 }
2949 }
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002950 /* If all the conditions below are validated, this means
2951 * we're evaluating a server managed by SRV resolution
2952 */
2953 else if (fqdn && !srv->hostname && srvrecord) {
2954 int res;
2955
2956 /* we can't apply previous state if SRV record has changed */
2957 if (srv->srvrq && strcmp(srv->srvrq->name, srvrecord) != 0) {
2958 chunk_appendf(msg, ", SRV record mismatch between configuration ('%s') and state file ('%s) for server '%s'. Previous state not applied", srv->srvrq->name, srvrecord, srv->id);
2959 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2960 goto out;
2961 }
2962
2963 /* create or find a SRV resolution for this srv record */
2964 if (srv->srvrq == NULL && (srv->srvrq = find_srvrq_by_name(srvrecord, srv->proxy)) == NULL)
2965 srv->srvrq = new_dns_srvrq(srv, srvrecord);
2966 if (srv->srvrq == NULL) {
2967 chunk_appendf(msg, ", can't create or find SRV resolution '%s' for server '%s'", srvrecord, srv->id);
2968 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2969 goto out;
2970 }
2971
2972 /* prepare DNS resolution for this server */
2973 res = srv_prepare_for_resolution(srv, fqdn);
2974 if (res == -1) {
2975 chunk_appendf(msg, ", can't allocate memory for DNS resolution for server '%s'", srv->id);
2976 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
2977 goto out;
2978 }
2979
2980 /* configure check.port accordingly */
2981 if ((srv->check.state & CHK_ST_CONFIGURED) &&
2982 !(srv->flags & SRV_F_CHECKPORT))
2983 srv->check.port = port;
2984
2985 /* Unset SRV_F_MAPPORTS for SRV records.
2986 * SRV_F_MAPPORTS is unfortunately set by parse_server()
2987 * because no ports are provided in the configuration file.
2988 * This is because HAProxy will use the port found into the SRV record.
2989 */
2990 srv->flags &= ~SRV_F_MAPPORTS;
2991 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002992
Frédéric Lécaille31694712017-08-01 08:47:19 +02002993 if (port_str)
2994 srv->svc_port = port;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002995 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Frédéric Lécaille31694712017-08-01 08:47:19 +02002996
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002997 break;
2998 default:
2999 chunk_appendf(msg, ", version '%d' not supported", version);
3000 }
3001
3002 out:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003003 if (msg->data) {
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003004 chunk_appendf(msg, "\n");
Christopher Faulet767a84b2017-11-24 16:50:31 +01003005 ha_warning("server-state application failed for server '%s/%s'%s",
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003006 srv->proxy->id, srv->id, msg->area);
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003007 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003008}
3009
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003010
3011/*
3012 * read next line from file <f> and return the server state version if one found.
3013 * If no version is found, then 0 is returned
3014 * Note that this should be the first read on <f>
3015 */
3016static int srv_state_get_version(FILE *f) {
3017 char buf[2];
3018 int ret;
3019
3020 /* first character of first line of the file must contain the version of the export */
3021 if (fgets(buf, 2, f) == NULL) {
3022 return 0;
3023 }
3024
3025 ret = atoi(buf);
3026 if ((ret < SRV_STATE_FILE_VERSION_MIN) ||
3027 (ret > SRV_STATE_FILE_VERSION_MAX))
3028 return 0;
3029
3030 return ret;
3031}
3032
3033
3034/*
3035 * parses server state line stored in <buf> and supposedly in version <version>.
3036 * Set <params> and <srv_params> accordingly.
3037 * In case of error, params[0] is set to NULL.
3038 */
3039static void srv_state_parse_line(char *buf, const int version, char **params, char **srv_params)
3040{
3041 int buflen, arg, srv_arg;
3042 char *cur, *end;
3043
3044 buflen = strlen(buf);
3045 cur = buf;
3046 end = cur + buflen;
3047
3048 /* we need at least one character */
3049 if (buflen == 0) {
3050 params[0] = NULL;
3051 return;
3052 }
3053
3054 /* ignore blank characters at the beginning of the line */
Willy Tarreau90807112020-02-25 08:16:33 +01003055 while (isspace((unsigned char)*cur))
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003056 ++cur;
3057
3058 /* Ignore empty or commented lines */
3059 if (cur == end || *cur == '#') {
3060 params[0] = NULL;
3061 return;
3062 }
3063
3064 /* truncated lines */
3065 if (buf[buflen - 1] != '\n') {
3066 //ha_warning("server-state file '%s': truncated line\n", filepath);
3067 params[0] = NULL;
3068 return;
3069 }
3070
3071 /* Removes trailing '\n' */
3072 buf[buflen - 1] = '\0';
3073
3074 /* we're now ready to move the line into *srv_params[] */
3075 params[0] = cur;
3076 arg = 1;
3077 srv_arg = 0;
3078 while (*cur && arg < SRV_STATE_FILE_MAX_FIELDS) {
Willy Tarreau90807112020-02-25 08:16:33 +01003079 if (isspace((unsigned char)*cur)) {
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003080 *cur = '\0';
3081 ++cur;
Willy Tarreau90807112020-02-25 08:16:33 +01003082 while (isspace((unsigned char)*cur))
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003083 ++cur;
3084 switch (version) {
3085 case 1:
3086 /*
3087 * srv_addr: params[4] => srv_params[0]
3088 * srv_op_state: params[5] => srv_params[1]
3089 * srv_admin_state: params[6] => srv_params[2]
3090 * srv_uweight: params[7] => srv_params[3]
3091 * srv_iweight: params[8] => srv_params[4]
3092 * srv_last_time_change: params[9] => srv_params[5]
3093 * srv_check_status: params[10] => srv_params[6]
3094 * srv_check_result: params[11] => srv_params[7]
3095 * srv_check_health: params[12] => srv_params[8]
3096 * srv_check_state: params[13] => srv_params[9]
3097 * srv_agent_state: params[14] => srv_params[10]
3098 * bk_f_forced_id: params[15] => srv_params[11]
3099 * srv_f_forced_id: params[16] => srv_params[12]
3100 * srv_fqdn: params[17] => srv_params[13]
3101 * srv_port: params[18] => srv_params[14]
3102 * srvrecord: params[19] => srv_params[15]
3103 */
3104 if (arg >= 4) {
3105 srv_params[srv_arg] = cur;
3106 ++srv_arg;
3107 }
3108 break;
3109 }
3110
3111 params[arg] = cur;
3112 ++arg;
3113 }
3114 else {
3115 ++cur;
3116 }
3117 }
3118
3119 /* if line is incomplete line, then ignore it.
3120 * otherwise, update useful flags */
3121 switch (version) {
3122 case 1:
3123 if (arg < SRV_STATE_FILE_NB_FIELDS_VERSION_1) {
3124 params[0] = NULL;
3125 return;
3126 }
3127 break;
3128 }
3129
3130 return;
3131}
3132
3133
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003134/* This function parses all the proxies and only take care of the backends (since we're looking for server)
3135 * For each proxy, it does the following:
3136 * - opens its server state file (either one or local one)
3137 * - read whole file, line by line
3138 * - analyse each line to check if it matches our current backend:
3139 * - backend name matches
3140 * - backend id matches if id is forced and name doesn't match
3141 * - if the server pointed by the line is found, then state is applied
3142 *
3143 * If the running backend uuid or id differs from the state file, then HAProxy reports
3144 * a warning.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003145 *
3146 * Grabs the server's lock via srv_update_state().
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003147 */
3148void apply_server_state(void)
3149{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003150 char mybuf[SRV_STATE_LINE_MAXLEN];
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003151 char *params[SRV_STATE_FILE_MAX_FIELDS] = {0};
3152 char *srv_params[SRV_STATE_FILE_MAX_FIELDS] = {0};
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003153 int version, global_file_version;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003154 FILE *f;
3155 char *filepath;
3156 char globalfilepath[MAXPATHLEN + 1];
3157 char localfilepath[MAXPATHLEN + 1];
3158 int len, fileopenerr, globalfilepathlen, localfilepathlen;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003159 struct proxy *curproxy, *bk;
3160 struct server *srv;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003161 char *line;
3162 char *bkname, *srvname;
3163 struct state_line *st;
3164 struct ebmb_node *node, *next_node;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003165
Willy Tarreau2d067f92020-07-16 06:40:27 +02003166 f = NULL;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003167 global_file_version = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003168 globalfilepathlen = 0;
3169 /* create the globalfilepath variable */
3170 if (global.server_state_file) {
3171 /* absolute path or no base directory provided */
3172 if ((global.server_state_file[0] == '/') || (!global.server_state_base)) {
3173 len = strlen(global.server_state_file);
3174 if (len > MAXPATHLEN) {
3175 globalfilepathlen = 0;
3176 goto globalfileerror;
3177 }
3178 memcpy(globalfilepath, global.server_state_file, len);
3179 globalfilepath[len] = '\0';
3180 globalfilepathlen = len;
3181 }
3182 else if (global.server_state_base) {
3183 len = strlen(global.server_state_base);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003184 if (len > MAXPATHLEN) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003185 globalfilepathlen = 0;
3186 goto globalfileerror;
3187 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003188 memcpy(globalfilepath, global.server_state_base, len);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003189 globalfilepath[len] = 0;
3190 globalfilepathlen = len;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003191
3192 /* append a slash if needed */
3193 if (!globalfilepathlen || globalfilepath[globalfilepathlen - 1] != '/') {
3194 if (globalfilepathlen + 1 > MAXPATHLEN) {
3195 globalfilepathlen = 0;
3196 goto globalfileerror;
3197 }
3198 globalfilepath[globalfilepathlen++] = '/';
3199 }
3200
3201 len = strlen(global.server_state_file);
3202 if (globalfilepathlen + len > MAXPATHLEN) {
3203 globalfilepathlen = 0;
3204 goto globalfileerror;
3205 }
3206 memcpy(globalfilepath + globalfilepathlen, global.server_state_file, len);
3207 globalfilepathlen += len;
3208 globalfilepath[globalfilepathlen++] = 0;
3209 }
3210 }
3211 globalfileerror:
3212 if (globalfilepathlen == 0)
3213 globalfilepath[0] = '\0';
3214
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003215 /* Load global server state in a tree */
3216 if (globalfilepathlen > 0) {
3217 errno = 0;
3218 f = fopen(globalfilepath, "r");
3219 if (errno)
3220 ha_warning("Can't open global server state file '%s': %s\n", globalfilepath, strerror(errno));
Vedran Furac5d486272019-10-16 14:49:38 +02003221 if (!f)
3222 goto out_load_server_state_in_tree;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003223
3224 global_file_version = srv_state_get_version(f);
3225 if (global_file_version == 0)
3226 goto out_load_server_state_in_tree;
3227
3228 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3229 line = NULL;
3230
3231 line = strdup(mybuf);
3232 if (line == NULL)
3233 continue;
3234
3235 srv_state_parse_line(mybuf, global_file_version, params, srv_params);
3236 if (params[0] == NULL)
Willy Tarreauca7a5af2019-12-20 17:26:27 +01003237 goto nextline;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003238
3239 /* bkname */
3240 bkname = params[1];
3241 /* srvname */
3242 srvname = params[3];
3243
3244 /* key */
3245 chunk_printf(&trash, "%s %s", bkname, srvname);
3246
3247 /* store line in tree */
Willy Tarreau7d6a1fa2019-12-20 17:18:13 +01003248 st = calloc(1, sizeof(*st) + trash.data + 1);
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003249 if (st == NULL) {
3250 goto nextline;
3251 }
Willy Tarreau7d6a1fa2019-12-20 17:18:13 +01003252 memcpy(st->name_name.key, trash.area, trash.data + 1);
Willy Tarreaufd1aa012019-12-20 17:23:40 +01003253 if (ebst_insert(&state_file, &st->name_name) != &st->name_name) {
3254 /* this is a duplicate key, probably a hand-crafted file,
3255 * drop it!
3256 */
3257 goto nextline;
3258 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003259
3260 /* save line */
3261 st->line = line;
3262
3263 continue;
3264
3265 nextline:
3266 /* free up memory in case of error during the processing of the line */
3267 free(line);
3268 }
3269 }
3270 out_load_server_state_in_tree:
3271
Ilya Shipitsindc6e8a92020-07-16 02:02:40 +05003272 if (f) {
3273 fclose(f);
3274 f = NULL;
3275 }
3276
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003277 /* parse all proxies and load states form tree (global file) or from local file */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003278 for (curproxy = proxies_list; curproxy != NULL; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003279 /* servers are only in backends */
3280 if (!(curproxy->cap & PR_CAP_BE))
3281 continue;
3282 fileopenerr = 0;
3283 filepath = NULL;
3284
3285 /* search server state file path and name */
3286 switch (curproxy->load_server_state_from_file) {
3287 /* read servers state from global file */
3288 case PR_SRV_STATE_FILE_GLOBAL:
3289 /* there was an error while generating global server state file path */
3290 if (globalfilepathlen == 0)
3291 continue;
3292 filepath = globalfilepath;
3293 fileopenerr = 1;
3294 break;
3295 /* this backend has its own file */
3296 case PR_SRV_STATE_FILE_LOCAL:
3297 localfilepathlen = 0;
3298 localfilepath[0] = '\0';
3299 len = 0;
3300 /* create the localfilepath variable */
3301 /* absolute path or no base directory provided */
3302 if ((curproxy->server_state_file_name[0] == '/') || (!global.server_state_base)) {
3303 len = strlen(curproxy->server_state_file_name);
3304 if (len > MAXPATHLEN) {
3305 localfilepathlen = 0;
3306 goto localfileerror;
3307 }
3308 memcpy(localfilepath, curproxy->server_state_file_name, len);
3309 localfilepath[len] = '\0';
3310 localfilepathlen = len;
3311 }
3312 else if (global.server_state_base) {
3313 len = strlen(global.server_state_base);
3314 localfilepathlen += len;
3315
3316 if (localfilepathlen > MAXPATHLEN) {
3317 localfilepathlen = 0;
3318 goto localfileerror;
3319 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003320 memcpy(localfilepath, global.server_state_base, len);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003321 localfilepath[localfilepathlen] = 0;
3322
3323 /* append a slash if needed */
3324 if (!localfilepathlen || localfilepath[localfilepathlen - 1] != '/') {
3325 if (localfilepathlen + 1 > MAXPATHLEN) {
3326 localfilepathlen = 0;
3327 goto localfileerror;
3328 }
3329 localfilepath[localfilepathlen++] = '/';
3330 }
3331
3332 len = strlen(curproxy->server_state_file_name);
3333 if (localfilepathlen + len > MAXPATHLEN) {
3334 localfilepathlen = 0;
3335 goto localfileerror;
3336 }
3337 memcpy(localfilepath + localfilepathlen, curproxy->server_state_file_name, len);
3338 localfilepathlen += len;
3339 localfilepath[localfilepathlen++] = 0;
3340 }
3341 filepath = localfilepath;
3342 localfileerror:
3343 if (localfilepathlen == 0)
3344 localfilepath[0] = '\0';
3345
3346 break;
3347 case PR_SRV_STATE_FILE_NONE:
3348 default:
3349 continue;
3350 }
3351
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003352 /* when global file is used, we get data from the tree
3353 * Note that in such case we don't check backend name neither uuid.
3354 * Backend name can't be wrong since it's used as a key to retrieve the server state
3355 * line from the tree.
3356 */
3357 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_GLOBAL) {
3358 struct server *srv = curproxy->srv;
3359 while (srv) {
3360 struct ebmb_node *node;
3361 struct state_line *st;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003362
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003363 chunk_printf(&trash, "%s %s", curproxy->id, srv->id);
3364 node = ebst_lookup(&state_file, trash.area);
3365 if (!node)
3366 goto next;
Dragan Dosencf4fb032015-11-04 23:03:26 +01003367
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003368 st = container_of(node, struct state_line, name_name);
3369 memcpy(mybuf, st->line, strlen(st->line));
3370 mybuf[strlen(st->line)] = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003371
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003372 srv_state_parse_line(mybuf, global_file_version, params, srv_params);
3373 if (params[0] == NULL)
3374 goto next;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003375
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003376 srv_update_state(srv, global_file_version, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003377
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003378 next:
3379 srv = srv->next;
3380 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003381
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003382 continue; /* next proxy in list */
3383 }
3384 else {
3385 /* load 'local' state file */
3386 errno = 0;
3387 f = fopen(filepath, "r");
3388 if (errno && fileopenerr)
3389 ha_warning("Can't open server state file '%s': %s\n", filepath, strerror(errno));
3390 if (!f)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003391 continue;
3392
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003393 mybuf[0] = '\0';
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003394
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003395 /* first character of first line of the file must contain the version of the export */
3396 version = srv_state_get_version(f);
3397 if (version == 0) {
3398 ha_warning("Can't get version of the server state file '%s'\n", filepath);
3399 goto fileclose;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003400 }
3401
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003402 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3403 int bk_f_forced_id = 0;
3404 int check_id = 0;
3405 int check_name = 0;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003406
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003407 srv_state_parse_line(mybuf, version, params, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003408
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003409 if (params[0] == NULL) {
3410 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003411 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003412
3413 /* if line is incomplete line, then ignore it.
3414 * otherwise, update useful flags */
3415 switch (version) {
3416 case 1:
3417 bk_f_forced_id = (atoi(params[15]) & PR_O_FORCED_ID);
3418 check_id = (atoi(params[0]) == curproxy->uuid);
3419 check_name = (strcmp(curproxy->id, params[1]) == 0);
3420 break;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003421 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003422
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003423 bk = curproxy;
3424
3425 /* if backend can't be found, let's continue */
3426 if (!check_id && !check_name)
3427 continue;
3428 else if (!check_id && check_name) {
3429 ha_warning("backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3430 send_log(bk, LOG_NOTICE, "backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3431 }
3432 else if (check_id && !check_name) {
3433 ha_warning("backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3434 send_log(bk, LOG_NOTICE, "backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3435 /* if name doesn't match, we still want to update curproxy if the backend id
3436 * was forced in previous the previous configuration */
3437 if (!bk_f_forced_id)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003438 continue;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003439 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003440
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003441 /* look for the server by its name: param[3] */
3442 srv = server_find_best_match(bk, params[3], 0, NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003443
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003444 if (!srv) {
3445 /* if no server found, then warning and continue with next line */
3446 ha_warning("can't find server '%s' in backend '%s'\n",
3447 params[3], params[1]);
3448 send_log(bk, LOG_NOTICE, "can't find server '%s' in backend '%s'\n",
3449 params[3], params[1]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003450 continue;
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003451 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003452
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003453 /* now we can proceed with server's state update */
3454 srv_update_state(srv, version, srv_params);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003455 }
Ilya Shipitsindc6e8a92020-07-16 02:02:40 +05003456
3457 fileclose:
3458 fclose(f);
3459
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003460 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003461 }
Baptiste Assmannda29fe22019-06-13 13:24:29 +02003462
3463 /* now free memory allocated for the tree */
3464 for (node = ebmb_first(&state_file), next_node = node ? ebmb_next(node) : NULL;
3465 node;
3466 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
3467 st = container_of(node, struct state_line, name_name);
3468 ebmb_delete(&st->name_name);
3469 free(st->line);
3470 free(st);
3471 }
3472
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003473}
3474
Simon Horman7d09b9a2013-02-12 10:45:51 +09003475/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02003476 * update a server's current IP address.
3477 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
3478 * ip is in network format.
3479 * updater is a string which contains an information about the requester of the update.
3480 * updater is used if not NULL.
3481 *
3482 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003483 *
3484 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02003485 */
Thierry Fournierd35b7a62016-02-24 08:23:22 +01003486int update_server_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02003487{
3488 /* generates a log line and a warning on stderr */
3489 if (1) {
3490 /* book enough space for both IPv4 and IPv6 */
3491 char oldip[INET6_ADDRSTRLEN];
3492 char newip[INET6_ADDRSTRLEN];
3493
3494 memset(oldip, '\0', INET6_ADDRSTRLEN);
3495 memset(newip, '\0', INET6_ADDRSTRLEN);
3496
3497 /* copy old IP address in a string */
3498 switch (s->addr.ss_family) {
3499 case AF_INET:
3500 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
3501 break;
3502 case AF_INET6:
3503 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
3504 break;
3505 };
3506
3507 /* copy new IP address in a string */
3508 switch (ip_sin_family) {
3509 case AF_INET:
3510 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
3511 break;
3512 case AF_INET6:
3513 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
3514 break;
3515 };
3516
3517 /* save log line into a buffer */
3518 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
3519 s->proxy->id, s->id, oldip, newip, updater);
3520
3521 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003522 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003523
3524 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003525 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003526 }
3527
3528 /* save the new IP family */
3529 s->addr.ss_family = ip_sin_family;
3530 /* save the new IP address */
3531 switch (ip_sin_family) {
3532 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02003533 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003534 break;
3535 case AF_INET6:
3536 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
3537 break;
3538 };
Olivier Houchard4e694042017-03-14 20:01:29 +01003539 srv_set_dyncookie(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003540
3541 return 0;
3542}
3543
3544/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003545 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3546 *
3547 * Caller can pass its name through <updater> to get it integrated in the response message
3548 * returned by the function.
3549 *
3550 * The function first does the following, in that order:
3551 * - validates the new addr and/or port
3552 * - checks if an update is required (new IP or port is different than current ones)
3553 * - checks the update is allowed:
3554 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3555 * - allow all changes if no CHECKS are configured
3556 * - if CHECK is configured:
3557 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3558 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3559 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02003560 *
3561 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003562 */
3563const char *update_server_addr_port(struct server *s, const char *addr, const char *port, char *updater)
3564{
3565 struct sockaddr_storage sa;
3566 int ret, port_change_required;
3567 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003568 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02003569 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003570 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003571
3572 msg = get_trash_chunk();
3573 chunk_reset(msg);
3574
3575 if (addr) {
3576 memset(&sa, 0, sizeof(struct sockaddr_storage));
3577 if (str2ip2(addr, &sa, 0) == NULL) {
3578 chunk_printf(msg, "Invalid addr '%s'", addr);
3579 goto out;
3580 }
3581
3582 /* changes are allowed on AF_INET* families only */
3583 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3584 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3585 goto out;
3586 }
3587
3588 /* collecting data currently setup */
3589 memset(current_addr, '\0', sizeof(current_addr));
3590 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3591 /* changes are allowed on AF_INET* families only */
3592 if ((ret != AF_INET) && (ret != AF_INET6)) {
3593 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3594 goto out;
3595 }
3596
3597 /* applying ADDR changes if required and allowed
3598 * ipcmp returns 0 when both ADDR are the same
3599 */
3600 if (ipcmp(&s->addr, &sa) == 0) {
3601 chunk_appendf(msg, "no need to change the addr");
3602 goto port;
3603 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003604 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003605 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003606
3607 /* we also need to update check's ADDR only if it uses the server's one */
3608 if ((s->check.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_CHECKADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003609 ipcpy(&sa, &s->check.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003610 }
3611
3612 /* we also need to update agent ADDR only if it use the server's one */
3613 if ((s->agent.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_AGENTADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003614 ipcpy(&sa, &s->agent.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003615 }
3616
3617 /* update report for caller */
3618 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3619 }
3620
3621 port:
3622 if (port) {
3623 char sign = '\0';
3624 char *endptr;
3625
3626 if (addr)
3627 chunk_appendf(msg, ", ");
3628
3629 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003630 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003631
3632 /* check if PORT change is required */
3633 port_change_required = 0;
3634
3635 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003636 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003637 new_port = strtol(port, &endptr, 10);
3638 if ((errno != 0) || (port == endptr)) {
3639 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3640 goto out;
3641 }
3642
3643 /* check if caller triggers a port mapped or offset */
3644 if (sign == '-' || (sign == '+')) {
3645 /* check if server currently uses port map */
3646 if (!(s->flags & SRV_F_MAPPORTS)) {
3647 /* switch from fixed port to port map mandatorily triggers
3648 * a port change */
3649 port_change_required = 1;
3650 /* check is configured
3651 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3652 * prevent PORT change if check doesn't have it's dedicated port while switching
3653 * to port mapping */
3654 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3655 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.");
3656 goto out;
3657 }
3658 }
3659 /* we're already using port maps */
3660 else {
3661 port_change_required = current_port != new_port;
3662 }
3663 }
3664 /* fixed port */
3665 else {
3666 port_change_required = current_port != new_port;
3667 }
3668
3669 /* applying PORT changes if required and update response message */
3670 if (port_change_required) {
3671 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003672 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003673 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003674
3675 /* prepare message */
3676 chunk_appendf(msg, "port changed from '");
3677 if (s->flags & SRV_F_MAPPORTS)
3678 chunk_appendf(msg, "+");
3679 chunk_appendf(msg, "%d' to '", current_port);
3680
3681 if (sign == '-') {
3682 s->flags |= SRV_F_MAPPORTS;
3683 chunk_appendf(msg, "%c", sign);
3684 /* just use for result output */
3685 new_port = -new_port;
3686 }
3687 else if (sign == '+') {
3688 s->flags |= SRV_F_MAPPORTS;
3689 chunk_appendf(msg, "%c", sign);
3690 }
3691 else {
3692 s->flags &= ~SRV_F_MAPPORTS;
3693 }
3694
3695 chunk_appendf(msg, "%d'", new_port);
3696
3697 /* we also need to update health checks port only if it uses server's realport */
3698 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3699 s->check.port = new_port;
3700 }
3701 }
3702 else {
3703 chunk_appendf(msg, "no need to change the port");
3704 }
3705 }
3706
3707out:
William Dauchy6318d332020-05-02 21:52:36 +02003708 if (changed) {
3709 /* force connection cleanup on the given server */
3710 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01003711 srv_set_dyncookie(s);
William Dauchy6318d332020-05-02 21:52:36 +02003712 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003713 if (updater)
3714 chunk_appendf(msg, " by '%s'", updater);
3715 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003716 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003717}
3718
3719
3720/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003721 * update server status based on result of name resolution
3722 * returns:
3723 * 0 if server status is updated
3724 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003725 *
3726 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003727 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003728int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003729{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003730 struct dns_resolvers *resolvers = s->resolvers;
3731 struct dns_resolution *resolution = s->dns_requester->resolution;
3732 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003733
Jerome Magnin012261a2020-07-28 13:38:22 +02003734 /* If resolution is NULL we're dealing with SRV records Additional records */
3735 if (resolution == NULL) {
3736 if (s->next_admin & SRV_ADMF_RMAINT)
3737 return 1;
3738
3739 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
3740 return 0;
3741 }
3742
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003743 switch (resolution->status) {
3744 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003745 /* status when HAProxy has just (re)started.
3746 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003747 break;
3748
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003749 case RSLV_STATUS_VALID:
3750 /*
3751 * resume health checks
3752 * server will be turned back on if health check is safe
3753 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003754 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003755 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003756 return 1;
3757 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3758 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003759 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003760 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003761
Emeric Brun52a91d32017-08-31 14:41:55 +02003762 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003763 return 1;
3764 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3765 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3766 s->proxy->id, s->id);
3767
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003768 ha_warning("%s.\n", trash.area);
3769 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003770 return 0;
3771
3772 case RSLV_STATUS_NX:
3773 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003774 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3775 if (!tick_is_expired(exp, now_ms))
3776 break;
3777
3778 if (s->next_admin & SRV_ADMF_RMAINT)
3779 return 1;
3780 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3781 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003782
3783 case RSLV_STATUS_TIMEOUT:
3784 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003785 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3786 if (!tick_is_expired(exp, now_ms))
3787 break;
3788
3789 if (s->next_admin & SRV_ADMF_RMAINT)
3790 return 1;
3791 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3792 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003793
3794 case RSLV_STATUS_REFUSED:
3795 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003796 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3797 if (!tick_is_expired(exp, now_ms))
3798 break;
3799
3800 if (s->next_admin & SRV_ADMF_RMAINT)
3801 return 1;
3802 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3803 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003804
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003805 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003806 /* stop server if resolution failed for a long enough period */
3807 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3808 if (!tick_is_expired(exp, now_ms))
3809 break;
3810
3811 if (s->next_admin & SRV_ADMF_RMAINT)
3812 return 1;
3813 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3814 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003815 }
3816
3817 return 1;
3818}
3819
3820/*
3821 * Server Name Resolution valid response callback
3822 * It expects:
3823 * - <nameserver>: the name server which answered the valid response
3824 * - <response>: buffer containing a valid DNS response
3825 * - <response_len>: size of <response>
3826 * It performs the following actions:
3827 * - ignore response if current ip found and server family not met
3828 * - update with first new ip found if family is met and current IP is not found
3829 * returns:
3830 * 0 on error
3831 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003832 *
3833 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003834 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003835int snr_resolution_cb(struct dns_requester *requester, struct dns_nameserver *nameserver)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003836{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003837 struct server *s = NULL;
3838 struct dns_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003839 void *serverip, *firstip;
3840 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003841 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003842 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003843 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003844
Christopher Faulet67957bd2017-09-27 11:00:59 +02003845 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003846 if (!s)
3847 return 1;
3848
Christopher Faulet67957bd2017-09-27 11:00:59 +02003849 resolution = s->dns_requester->resolution;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003850
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003851 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003852 firstip = NULL; /* pointer to the first valid response found */
3853 /* it will be used as the new IP if a change is required */
3854 firstip_sin_family = AF_UNSPEC;
3855 serverip = NULL; /* current server IP address */
3856
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003857 /* initializing server IP pointer */
3858 server_sin_family = s->addr.ss_family;
3859 switch (server_sin_family) {
3860 case AF_INET:
3861 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3862 break;
3863
3864 case AF_INET6:
3865 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3866 break;
3867
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003868 case AF_UNSPEC:
3869 break;
3870
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003871 default:
3872 goto invalid;
3873 }
3874
Baptiste Assmann729c9012017-05-22 15:13:10 +02003875 ret = dns_get_ip_from_response(&resolution->response, &s->dns_opts,
Thierry Fournierada34842016-02-17 21:25:09 +01003876 serverip, server_sin_family, &firstip,
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003877 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003878
3879 switch (ret) {
3880 case DNS_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003881 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003882
3883 case DNS_UPD_SRVIP_NOT_FOUND:
3884 goto save_ip;
3885
3886 case DNS_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003887 goto invalid;
3888
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003889 case DNS_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003890 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003891 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003892
Baptiste Assmannfad03182015-10-28 02:03:32 +01003893 case DNS_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003894 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003895 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003896 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003897
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003898 default:
3899 goto invalid;
3900
3901 }
3902
3903 save_ip:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003904 if (nameserver) {
3905 nameserver->counters.update++;
3906 /* save the first ip we found */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003907 chunk_printf(chk, "%s/%s", nameserver->resolvers->id, nameserver->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003908 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003909 else
3910 chunk_printf(chk, "DNS cache");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003911 update_server_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003912
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003913 update_status:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003914 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003915 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003916
3917 invalid:
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003918 if (nameserver) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02003919 nameserver->counters.invalid++;
3920 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003921 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003922 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003923 return 0;
3924}
3925
3926/*
3927 * Server Name Resolution error management callback
3928 * returns:
3929 * 0 on error
3930 * 1 when no error or safe ignore
Willy Tarreau46b7f532018-08-21 11:54:26 +02003931 *
3932 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003933 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003934int snr_resolution_error_cb(struct dns_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003935{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003936 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003937
Christopher Faulet67957bd2017-09-27 11:00:59 +02003938 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003939 if (!s)
3940 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003941 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003942 snr_update_srv_status(s, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003943 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003944 return 1;
3945}
3946
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003947/*
3948 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003949 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003950 * It returns a pointer to the first server found or NULL if <ip> is not yet
3951 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003952 *
3953 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003954 */
3955struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3956{
3957 struct server *tmpsrv;
3958 struct proxy *be;
3959
3960 if (!srv)
3961 return NULL;
3962
3963 be = srv->proxy;
3964 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003965 /* we found the current server is the same, ignore it */
3966 if (srv == tmpsrv)
3967 continue;
3968
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003969 /* We want to compare the IP in the record with the IP of the servers in the
3970 * same backend, only if:
3971 * * DNS resolution is enabled on the server
3972 * * the hostname used for the resolution by our server is the same than the
3973 * one used for the server found in the backend
3974 * * the server found in the backend is not our current server
3975 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003976 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003977 if ((tmpsrv->hostname_dn == NULL) ||
3978 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
3979 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01003980 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003981 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003982 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003983 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003984
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003985 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01003986 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003987 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003988 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003989 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003990
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003991 /* At this point, we have 2 different servers using the same DNS hostname
3992 * for their respective resolution.
3993 */
3994 if (*ip_family == tmpsrv->addr.ss_family &&
3995 ((tmpsrv->addr.ss_family == AF_INET &&
3996 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3997 (tmpsrv->addr.ss_family == AF_INET6 &&
3998 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003999 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004000 return tmpsrv;
4001 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004002 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004003 }
4004
Emeric Brune9fd6b52017-11-02 17:20:39 +01004005
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004006 return NULL;
4007}
4008
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004009/* Sets the server's address (srv->addr) from srv->hostname using the libc's
4010 * resolver. This is suited for initial address configuration. Returns 0 on
4011 * success otherwise a non-zero error code. In case of error, *err_code, if
4012 * not NULL, is filled up.
4013 */
4014int srv_set_addr_via_libc(struct server *srv, int *err_code)
4015{
4016 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004017 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01004018 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004019 return 1;
4020 }
4021 return 0;
4022}
4023
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004024/* Set the server's FDQN (->hostname) from <hostname>.
4025 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004026 *
4027 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004028 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004029int srv_set_fqdn(struct server *srv, const char *hostname, int dns_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004030{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004031 struct dns_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004032 char *hostname_dn;
4033 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004034
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02004035 /* Note that the server lock is already held. */
4036 if (!srv->resolvers)
4037 return -1;
4038
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004039 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004040 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004041 /* run time DNS resolution was not active for this server
4042 * and we can't enable it at run time for now.
4043 */
4044 if (!srv->dns_requester)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004045 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004046
4047 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004048 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004049 hostname_dn = trash.area;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004050 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
4051 hostname_dn, trash.size);
4052 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004053 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004054
Christopher Faulet67957bd2017-09-27 11:00:59 +02004055 resolution = srv->dns_requester->resolution;
4056 if (resolution &&
4057 resolution->hostname_dn &&
4058 !strcmp(resolution->hostname_dn, hostname_dn))
Christopher Fauletb2812a62017-10-04 16:17:58 +02004059 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004060
Christopher Faulet67957bd2017-09-27 11:00:59 +02004061 dns_unlink_resolution(srv->dns_requester);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004062
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004063 free(srv->hostname);
4064 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004065 srv->hostname = strdup(hostname);
4066 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004067 srv->hostname_dn_len = hostname_dn_len;
4068 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004069 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004070
Baptiste Assmann13a92322019-06-07 09:40:55 +02004071 if (srv->flags & SRV_F_NO_RESOLUTION)
4072 goto end;
4073
Olivier Houchard55dcdf42017-11-06 15:15:04 +01004074 if (dns_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004075 goto err;
4076
4077 end:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004078 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004079 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004080 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02004081
4082 err:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004083 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004084 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02004085 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004086}
4087
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004088/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
4089 * from the state file. This is suited for initial address configuration.
4090 * Returns 0 on success otherwise a non-zero error code. In case of error,
4091 * *err_code, if not NULL, is filled up.
4092 */
4093static int srv_apply_lastaddr(struct server *srv, int *err_code)
4094{
4095 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
4096 if (err_code)
4097 *err_code |= ERR_WARN;
4098 return 1;
4099 }
4100 return 0;
4101}
4102
Willy Tarreau25e51522016-11-04 15:10:17 +01004103/* returns 0 if no error, otherwise a combination of ERR_* flags */
4104static int srv_iterate_initaddr(struct server *srv)
4105{
4106 int return_code = 0;
4107 int err_code;
4108 unsigned int methods;
4109
4110 methods = srv->init_addr_methods;
4111 if (!methods) { // default to "last,libc"
4112 srv_append_initaddr(&methods, SRV_IADDR_LAST);
4113 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
4114 }
4115
Willy Tarreau3eed10e2016-11-07 21:03:16 +01004116 /* "-dr" : always append "none" so that server addresses resolution
4117 * failures are silently ignored, this is convenient to validate some
4118 * configs out of their environment.
4119 */
4120 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
4121 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4122
Willy Tarreau25e51522016-11-04 15:10:17 +01004123 while (methods) {
4124 err_code = 0;
4125 switch (srv_get_next_initaddr(&methods)) {
4126 case SRV_IADDR_LAST:
4127 if (!srv->lastaddr)
4128 continue;
4129 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004130 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004131 return_code |= err_code;
4132 break;
4133
4134 case SRV_IADDR_LIBC:
4135 if (!srv->hostname)
4136 continue;
4137 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004138 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004139 return_code |= err_code;
4140 break;
4141
Willy Tarreau37ebe122016-11-04 15:17:58 +01004142 case SRV_IADDR_NONE:
4143 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004144 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004145 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
4146 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004147 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01004148 return return_code;
4149
Willy Tarreau4310d362016-11-02 15:05:56 +01004150 case SRV_IADDR_IP:
4151 ipcpy(&srv->init_addr, &srv->addr);
4152 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004153 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', falling back to configured address.\n",
4154 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
Willy Tarreau4310d362016-11-02 15:05:56 +01004155 }
Olivier Houchard4e694042017-03-14 20:01:29 +01004156 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01004157
Willy Tarreau25e51522016-11-04 15:10:17 +01004158 default: /* unhandled method */
4159 break;
4160 }
4161 }
4162
4163 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004164 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Willy Tarreau25e51522016-11-04 15:10:17 +01004165 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
4166 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01004167 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004168 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Willy Tarreau465b6e52016-11-07 19:19:22 +01004169 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
4170 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004171
4172 return_code |= ERR_ALERT | ERR_FATAL;
4173 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01004174out:
4175 srv_set_dyncookie(srv);
4176 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01004177}
4178
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004179/*
4180 * This function parses all backends and all servers within each backend
4181 * and performs servers' addr resolution based on information provided by:
4182 * - configuration file
4183 * - server-state file (states provided by an 'old' haproxy process)
4184 *
4185 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
4186 */
4187int srv_init_addr(void)
4188{
4189 struct proxy *curproxy;
4190 int return_code = 0;
4191
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004192 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004193 while (curproxy) {
4194 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004195
4196 /* servers are in backend only */
4197 if (!(curproxy->cap & PR_CAP_BE))
4198 goto srv_init_addr_next;
4199
Willy Tarreau25e51522016-11-04 15:10:17 +01004200 for (srv = curproxy->srv; srv; srv = srv->next)
Willy Tarreau3d609a72017-09-06 14:22:45 +02004201 if (srv->hostname)
4202 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004203
4204 srv_init_addr_next:
4205 curproxy = curproxy->next;
4206 }
4207
4208 return return_code;
4209}
4210
Willy Tarreau46b7f532018-08-21 11:54:26 +02004211/*
4212 * Must be called with the server lock held.
4213 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004214const 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 +02004215{
4216
Willy Tarreau83061a82018-07-13 11:56:34 +02004217 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004218
4219 msg = get_trash_chunk();
4220 chunk_reset(msg);
4221
Olivier Houchard8da5f982017-08-04 18:35:36 +02004222 if (server->hostname && !strcmp(fqdn, server->hostname)) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004223 chunk_appendf(msg, "no need to change the FDQN");
4224 goto out;
4225 }
4226
4227 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
4228 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
4229 goto out;
4230 }
4231
4232 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
4233 server->proxy->id, server->id, server->hostname, fqdn);
4234
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004235 if (srv_set_fqdn(server, fqdn, dns_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004236 chunk_reset(msg);
4237 chunk_appendf(msg, "could not update %s/%s FQDN",
4238 server->proxy->id, server->id);
4239 goto out;
4240 }
4241
4242 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02004243 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004244
4245 out:
4246 if (updater)
4247 chunk_appendf(msg, " by '%s'", updater);
4248 chunk_appendf(msg, "\n");
4249
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004250 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004251}
4252
4253
Willy Tarreau21b069d2016-11-23 17:15:08 +01004254/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
4255 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004256 * 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 +01004257 * used for CLI commands requiring a server name.
4258 * Important: the <arg> is modified to remove the '/'.
4259 */
4260struct server *cli_find_server(struct appctx *appctx, char *arg)
4261{
4262 struct proxy *px;
4263 struct server *sv;
4264 char *line;
4265
4266 /* split "backend/server" and make <line> point to server */
4267 for (line = arg; *line; line++)
4268 if (*line == '/') {
4269 *line++ = '\0';
4270 break;
4271 }
4272
4273 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004274 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004275 return NULL;
4276 }
4277
4278 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004279 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004280 return NULL;
4281 }
4282
4283 if (px->state == PR_STSTOPPED) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004284 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01004285 return NULL;
4286 }
4287
4288 return sv;
4289}
4290
William Lallemand222baf22016-11-19 02:00:33 +01004291
Willy Tarreau46b7f532018-08-21 11:54:26 +02004292/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004293static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01004294{
4295 struct server *sv;
4296 const char *warning;
4297
4298 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4299 return 1;
4300
4301 sv = cli_find_server(appctx, args[2]);
4302 if (!sv)
4303 return 1;
4304
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004305 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02004306
William Lallemand222baf22016-11-19 02:00:33 +01004307 if (strcmp(args[3], "weight") == 0) {
4308 warning = server_parse_weight_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004309 if (warning)
4310 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004311 }
4312 else if (strcmp(args[3], "state") == 0) {
4313 if (strcmp(args[4], "ready") == 0)
4314 srv_adm_set_ready(sv);
4315 else if (strcmp(args[4], "drain") == 0)
4316 srv_adm_set_drain(sv);
4317 else if (strcmp(args[4], "maint") == 0)
4318 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02004319 else
4320 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004321 }
4322 else if (strcmp(args[3], "health") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004323 if (sv->track)
4324 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004325 else if (strcmp(args[4], "up") == 0) {
4326 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004327 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004328 }
4329 else if (strcmp(args[4], "stopping") == 0) {
4330 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004331 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004332 }
4333 else if (strcmp(args[4], "down") == 0) {
4334 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004335 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004336 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004337 else
4338 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004339 }
4340 else if (strcmp(args[3], "agent") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004341 if (!(sv->agent.state & CHK_ST_ENABLED))
4342 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004343 else if (strcmp(args[4], "up") == 0) {
4344 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004345 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004346 }
4347 else if (strcmp(args[4], "down") == 0) {
4348 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004349 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004350 }
Willy Tarreau9d008692019-08-09 11:21:01 +02004351 else
4352 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004353 }
Misiek2da082d2017-01-09 09:40:42 +01004354 else if (strcmp(args[3], "agent-addr") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004355 if (!(sv->agent.state & CHK_ST_ENABLED))
4356 cli_err(appctx, "agent checks are not enabled on this server.\n");
4357 else if (str2ip(args[4], &sv->agent.addr) == NULL)
4358 cli_err(appctx, "incorrect addr address given for agent.\n");
Misiek2da082d2017-01-09 09:40:42 +01004359 }
4360 else if (strcmp(args[3], "agent-send") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004361 if (!(sv->agent.state & CHK_ST_ENABLED))
4362 cli_err(appctx, "agent checks are not enabled on this server.\n");
4363 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02004364 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02004365 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01004366 }
4367 }
William Lallemand222baf22016-11-19 02:00:33 +01004368 else if (strcmp(args[3], "check-port") == 0) {
4369 int i = 0;
4370 if (strl2irc(args[4], strlen(args[4]), &i) != 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004371 cli_err(appctx, "'set server <srv> check-port' expects an integer as argument.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004372 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004373 }
4374 if ((i < 0) || (i > 65535)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004375 cli_err(appctx, "provided port is not valid.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004376 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004377 }
4378 /* prevent the update of port to 0 if MAPPORTS are in use */
4379 if ((sv->flags & SRV_F_MAPPORTS) && (i == 0)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004380 cli_err(appctx, "can't unset 'port' since MAPPORTS is in use.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004381 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004382 }
4383 sv->check.port = i;
Willy Tarreau9d008692019-08-09 11:21:01 +02004384 cli_msg(appctx, LOG_NOTICE, "health check port updated.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004385 }
4386 else if (strcmp(args[3], "addr") == 0) {
4387 char *addr = NULL;
4388 char *port = NULL;
4389 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004390 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004391 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004392 }
4393 else {
4394 addr = args[4];
4395 }
4396 if (strcmp(args[5], "port") == 0) {
4397 port = args[6];
4398 }
4399 warning = update_server_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02004400 if (warning)
4401 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01004402 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
4403 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004404 else if (strcmp(args[3], "fqdn") == 0) {
4405 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02004406 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004407 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004408 }
Baptiste Assmann13a92322019-06-07 09:40:55 +02004409 /* ensure runtime resolver will process this new fqdn */
4410 if (sv->flags & SRV_F_NO_RESOLUTION) {
4411 sv->flags &= ~SRV_F_NO_RESOLUTION;
4412 }
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004413 warning = update_server_fqdn(sv, args[4], "stats socket command", 0);
Willy Tarreau9d008692019-08-09 11:21:01 +02004414 if (warning)
4415 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004416 }
William Lallemand222baf22016-11-19 02:00:33 +01004417 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02004418 cli_err(appctx,
4419 "'set server <srv>' only supports 'agent', 'health', 'state',"
4420 " 'weight', 'addr', 'fqdn' and 'check-port'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01004421 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004422 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004423 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004424 return 1;
4425}
4426
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004427static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004428{
4429 struct stream_interface *si = appctx->owner;
4430 struct proxy *px;
4431 struct server *sv;
4432 char *line;
4433
4434
4435 /* split "backend/server" and make <line> point to server */
4436 for (line = args[2]; *line; line++)
4437 if (*line == '/') {
4438 *line++ = '\0';
4439 break;
4440 }
4441
Willy Tarreau9d008692019-08-09 11:21:01 +02004442 if (!*line)
4443 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004444
Willy Tarreau9d008692019-08-09 11:21:01 +02004445 if (!get_backend_server(args[2], line, &px, &sv))
4446 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01004447
4448 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004449 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
4450 sv->iweight);
4451 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004452 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004453 return 0;
4454 }
William Lallemand6b160942016-11-22 12:34:35 +01004455 return 1;
4456}
4457
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004458/* Parse a "set weight" command.
4459 *
4460 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004461 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004462static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004463{
4464 struct server *sv;
4465 const char *warning;
4466
4467 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4468 return 1;
4469
4470 sv = cli_find_server(appctx, args[2]);
4471 if (!sv)
4472 return 1;
4473
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004474 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4475
William Lallemand6b160942016-11-22 12:34:35 +01004476 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004477 if (warning)
4478 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004479
4480 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4481
William Lallemand6b160942016-11-22 12:34:35 +01004482 return 1;
4483}
4484
Willy Tarreau46b7f532018-08-21 11:54:26 +02004485/* parse a "set maxconn server" command. It always returns 1.
4486 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004487 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004488 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004489static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01004490{
4491 struct server *sv;
4492 const char *warning;
4493
4494 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4495 return 1;
4496
4497 sv = cli_find_server(appctx, args[3]);
4498 if (!sv)
4499 return 1;
4500
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004501 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4502
Willy Tarreaub8026272016-11-23 11:26:56 +01004503 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02004504 if (warning)
4505 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004506
4507 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4508
Willy Tarreaub8026272016-11-23 11:26:56 +01004509 return 1;
4510}
William Lallemand6b160942016-11-22 12:34:35 +01004511
Willy Tarreau46b7f532018-08-21 11:54:26 +02004512/* parse a "disable agent" command. It always returns 1.
4513 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004514 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004515 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004516static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004517{
4518 struct server *sv;
4519
4520 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4521 return 1;
4522
4523 sv = cli_find_server(appctx, args[2]);
4524 if (!sv)
4525 return 1;
4526
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004527 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004528 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004529 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004530 return 1;
4531}
4532
Willy Tarreau46b7f532018-08-21 11:54:26 +02004533/* parse a "disable health" command. It always returns 1.
4534 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004535 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004536 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004537static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004538{
4539 struct server *sv;
4540
4541 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4542 return 1;
4543
4544 sv = cli_find_server(appctx, args[2]);
4545 if (!sv)
4546 return 1;
4547
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004548 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004549 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004550 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004551 return 1;
4552}
4553
Willy Tarreau46b7f532018-08-21 11:54:26 +02004554/* parse a "disable server" command. It always returns 1.
4555 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004556 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004557 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004558static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004559{
4560 struct server *sv;
4561
4562 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4563 return 1;
4564
4565 sv = cli_find_server(appctx, args[2]);
4566 if (!sv)
4567 return 1;
4568
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004569 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004570 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004571 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004572 return 1;
4573}
4574
Willy Tarreau46b7f532018-08-21 11:54:26 +02004575/* parse a "enable agent" command. It always returns 1.
4576 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004577 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004578 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004579static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004580{
4581 struct server *sv;
4582
4583 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4584 return 1;
4585
4586 sv = cli_find_server(appctx, args[2]);
4587 if (!sv)
4588 return 1;
4589
Willy Tarreau9d008692019-08-09 11:21:01 +02004590 if (!(sv->agent.state & CHK_ST_CONFIGURED))
4591 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004592
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004593 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004594 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004595 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004596 return 1;
4597}
4598
Willy Tarreau46b7f532018-08-21 11:54:26 +02004599/* parse a "enable health" command. It always returns 1.
4600 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004601 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004602 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004603static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004604{
4605 struct server *sv;
4606
4607 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4608 return 1;
4609
4610 sv = cli_find_server(appctx, args[2]);
4611 if (!sv)
4612 return 1;
4613
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004614 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004615 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004616 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004617 return 1;
4618}
4619
Willy Tarreau46b7f532018-08-21 11:54:26 +02004620/* parse a "enable server" command. It always returns 1.
4621 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004622 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004623 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004624static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004625{
4626 struct server *sv;
4627
4628 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4629 return 1;
4630
4631 sv = cli_find_server(appctx, args[2]);
4632 if (!sv)
4633 return 1;
4634
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004635 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004636 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004637 if (!(sv->flags & SRV_F_COOKIESET)
4638 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4639 sv->cookie)
4640 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004641 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004642 return 1;
4643}
4644
William Lallemand222baf22016-11-19 02:00:33 +01004645/* register cli keywords */
4646static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004647 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004648 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004649 { { "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 +01004650 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004651 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004652 { { "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 +01004653 { { "set", "maxconn", "server", NULL }, "set maxconn server : change a server's maxconn setting", cli_parse_set_maxconn_server, NULL },
William Lallemand222baf22016-11-19 02:00:33 +01004654 { { "set", "server", NULL }, "set server : change a server's state, weight or address", cli_parse_set_server },
William Lallemand6b160942016-11-22 12:34:35 +01004655 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4656 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4657
William Lallemand222baf22016-11-19 02:00:33 +01004658 {{},}
4659}};
4660
Willy Tarreau0108d902018-11-25 19:14:37 +01004661INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004662
Emeric Brun64cc49c2017-10-03 14:46:45 +02004663/*
4664 * This function applies server's status changes, it is
4665 * is designed to be called asynchronously.
4666 *
Willy Tarreau46b7f532018-08-21 11:54:26 +02004667 * Must be called with the server lock held.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004668 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004669static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004670{
4671 struct check *check = &s->check;
4672 int xferred;
4673 struct proxy *px = s->proxy;
4674 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4675 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4676 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004677 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004678
Emeric Brun64cc49c2017-10-03 14:46:45 +02004679 /* If currently main is not set we try to apply pending state changes */
4680 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4681 int next_admin;
4682
4683 /* Backup next admin */
4684 next_admin = s->next_admin;
4685
4686 /* restore current admin state */
4687 s->next_admin = s->cur_admin;
4688
4689 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4690 s->last_change = now.tv_sec;
4691 if (s->proxy->lbprm.set_server_status_down)
4692 s->proxy->lbprm.set_server_status_down(s);
4693
4694 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4695 srv_shutdown_streams(s, SF_ERR_DOWN);
4696
4697 /* we might have streams queued on this server and waiting for
4698 * a connection. Those which are redispatchable will be queued
4699 * to another server or to the proxy itself.
4700 */
4701 xferred = pendconn_redistribute(s);
4702
4703 tmptrash = alloc_trash_chunk();
4704 if (tmptrash) {
4705 chunk_printf(tmptrash,
4706 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4707 s->proxy->id, s->id);
4708
Emeric Brun5a133512017-10-19 14:42:30 +02004709 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004710 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004711
4712 /* we don't send an alert if the server was previously paused */
4713 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004714 send_log(s->proxy, log_level, "%s.\n",
4715 tmptrash->area);
4716 send_email_alert(s, log_level, "%s",
4717 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004718 free_trash_chunk(tmptrash);
4719 tmptrash = NULL;
4720 }
4721 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4722 set_backend_down(s->proxy);
4723
4724 s->counters.down_trans++;
4725 }
4726 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4727 s->last_change = now.tv_sec;
4728 if (s->proxy->lbprm.set_server_status_down)
4729 s->proxy->lbprm.set_server_status_down(s);
4730
4731 /* we might have streams queued on this server and waiting for
4732 * a connection. Those which are redispatchable will be queued
4733 * to another server or to the proxy itself.
4734 */
4735 xferred = pendconn_redistribute(s);
4736
4737 tmptrash = alloc_trash_chunk();
4738 if (tmptrash) {
4739 chunk_printf(tmptrash,
4740 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4741 s->proxy->id, s->id);
4742
Emeric Brun5a133512017-10-19 14:42:30 +02004743 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004744
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004745 ha_warning("%s.\n", tmptrash->area);
4746 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4747 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004748 free_trash_chunk(tmptrash);
4749 tmptrash = NULL;
4750 }
4751
4752 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4753 set_backend_down(s->proxy);
4754 }
4755 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4756 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4757 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4758 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4759 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4760 s->proxy->last_change = now.tv_sec;
4761 }
4762
4763 if (s->next_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
4764 s->down_time += now.tv_sec - s->last_change;
4765
4766 s->last_change = now.tv_sec;
4767 if (s->next_state == SRV_ST_STARTING)
4768 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4769
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004770 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004771 /* now propagate the status change to any LB algorithms */
4772 if (px->lbprm.update_server_eweight)
4773 px->lbprm.update_server_eweight(s);
4774 else if (srv_willbe_usable(s)) {
4775 if (px->lbprm.set_server_status_up)
4776 px->lbprm.set_server_status_up(s);
4777 }
4778 else {
4779 if (px->lbprm.set_server_status_down)
4780 px->lbprm.set_server_status_down(s);
4781 }
4782
4783 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4784 * and it's not a backup server and its effective weight is > 0,
4785 * then it can accept new connections, so we shut down all streams
4786 * on all backup servers.
4787 */
4788 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4789 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4790 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4791
4792 /* check if we can handle some connections queued at the proxy. We
4793 * will take as many as we can handle.
4794 */
4795 xferred = pendconn_grab_from_px(s);
4796
4797 tmptrash = alloc_trash_chunk();
4798 if (tmptrash) {
4799 chunk_printf(tmptrash,
4800 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4801 s->proxy->id, s->id);
4802
Emeric Brun5a133512017-10-19 14:42:30 +02004803 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004804 ha_warning("%s.\n", tmptrash->area);
4805 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4806 tmptrash->area);
4807 send_email_alert(s, LOG_NOTICE, "%s",
4808 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004809 free_trash_chunk(tmptrash);
4810 tmptrash = NULL;
4811 }
4812
4813 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4814 set_backend_down(s->proxy);
4815 }
4816 else if (s->cur_eweight != s->next_eweight) {
4817 /* now propagate the status change to any LB algorithms */
4818 if (px->lbprm.update_server_eweight)
4819 px->lbprm.update_server_eweight(s);
4820 else if (srv_willbe_usable(s)) {
4821 if (px->lbprm.set_server_status_up)
4822 px->lbprm.set_server_status_up(s);
4823 }
4824 else {
4825 if (px->lbprm.set_server_status_down)
4826 px->lbprm.set_server_status_down(s);
4827 }
4828
4829 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4830 set_backend_down(s->proxy);
4831 }
4832
4833 s->next_admin = next_admin;
4834 }
4835
Emeric Brun5a133512017-10-19 14:42:30 +02004836 /* reset operational state change */
4837 *s->op_st_chg.reason = 0;
4838 s->op_st_chg.status = s->op_st_chg.code = -1;
4839 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004840
4841 /* Now we try to apply pending admin changes */
4842
4843 /* Maintenance must also disable health checks */
4844 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4845 if (s->check.state & CHK_ST_ENABLED) {
4846 s->check.state |= CHK_ST_PAUSED;
4847 check->health = 0;
4848 }
4849
4850 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004851 tmptrash = alloc_trash_chunk();
4852 if (tmptrash) {
4853 chunk_printf(tmptrash,
4854 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4855 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4856 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004857
Olivier Houchard796a2b32017-10-24 17:42:47 +02004858 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004859
Olivier Houchard796a2b32017-10-24 17:42:47 +02004860 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004861 ha_warning("%s.\n", tmptrash->area);
4862 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4863 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004864 }
4865 free_trash_chunk(tmptrash);
4866 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004867 }
Emeric Brun8f298292017-12-06 16:47:17 +01004868 /* commit new admin status */
4869
4870 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004871 }
4872 else { /* server was still running */
4873 check->health = 0; /* failure */
4874 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004875
4876 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004877 if (s->proxy->lbprm.set_server_status_down)
4878 s->proxy->lbprm.set_server_status_down(s);
4879
Emeric Brun64cc49c2017-10-03 14:46:45 +02004880 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4881 srv_shutdown_streams(s, SF_ERR_DOWN);
4882
William Dauchy6318d332020-05-02 21:52:36 +02004883 /* force connection cleanup on the given server */
4884 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004885 /* we might have streams queued on this server and waiting for
4886 * a connection. Those which are redispatchable will be queued
4887 * to another server or to the proxy itself.
4888 */
4889 xferred = pendconn_redistribute(s);
4890
4891 tmptrash = alloc_trash_chunk();
4892 if (tmptrash) {
4893 chunk_printf(tmptrash,
4894 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
4895 s->flags & SRV_F_BACKUP ? "Backup " : "",
4896 s->proxy->id, s->id,
4897 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4898
4899 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
4900
4901 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004902 ha_warning("%s.\n", tmptrash->area);
4903 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
4904 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004905 }
4906 free_trash_chunk(tmptrash);
4907 tmptrash = NULL;
4908 }
4909 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4910 set_backend_down(s->proxy);
4911
4912 s->counters.down_trans++;
4913 }
4914 }
4915 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
4916 /* OK here we're leaving maintenance, we have many things to check,
4917 * because the server might possibly be coming back up depending on
4918 * its state. In practice, leaving maintenance means that we should
4919 * immediately turn to UP (more or less the slowstart) under the
4920 * following conditions :
4921 * - server is neither checked nor tracked
4922 * - server tracks another server which is not checked
4923 * - server tracks another server which is already up
4924 * Which sums up as something simpler :
4925 * "either the tracking server is up or the server's checks are disabled
4926 * or up". Otherwise we only re-enable health checks. There's a special
4927 * case associated to the stopping state which can be inherited. Note
4928 * that the server might still be in drain mode, which is naturally dealt
4929 * with by the lower level functions.
4930 */
4931
4932 if (s->check.state & CHK_ST_ENABLED) {
4933 s->check.state &= ~CHK_ST_PAUSED;
4934 check->health = check->rise; /* start OK but check immediately */
4935 }
4936
4937 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
4938 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
4939 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
4940 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
4941 s->next_state = SRV_ST_STOPPING;
4942 }
4943 else {
4944 s->next_state = SRV_ST_STARTING;
4945 if (s->slowstart > 0)
4946 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4947 else
4948 s->next_state = SRV_ST_RUNNING;
4949 }
4950
4951 }
4952
4953 tmptrash = alloc_trash_chunk();
4954 if (tmptrash) {
4955 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4956 chunk_printf(tmptrash,
4957 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
4958 s->flags & SRV_F_BACKUP ? "Backup " : "",
4959 s->proxy->id, s->id,
4960 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4961 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4962 }
4963 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4964 chunk_printf(tmptrash,
4965 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
4966 s->flags & SRV_F_BACKUP ? "Backup " : "",
4967 s->proxy->id, s->id, s->hostname,
4968 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4969 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4970 }
4971 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4972 chunk_printf(tmptrash,
4973 "%sServer %s/%s is %s/%s (leaving maintenance)",
4974 s->flags & SRV_F_BACKUP ? "Backup " : "",
4975 s->proxy->id, s->id,
4976 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4977 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4978 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004979 ha_warning("%s.\n", tmptrash->area);
4980 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4981 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004982 free_trash_chunk(tmptrash);
4983 tmptrash = NULL;
4984 }
4985
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004986 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004987 /* now propagate the status change to any LB algorithms */
4988 if (px->lbprm.update_server_eweight)
4989 px->lbprm.update_server_eweight(s);
4990 else if (srv_willbe_usable(s)) {
4991 if (px->lbprm.set_server_status_up)
4992 px->lbprm.set_server_status_up(s);
4993 }
4994 else {
4995 if (px->lbprm.set_server_status_down)
4996 px->lbprm.set_server_status_down(s);
4997 }
4998
4999 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5000 set_backend_down(s->proxy);
5001
Willy Tarreau6a78e612018-08-07 10:14:53 +02005002 /* If the server is set with "on-marked-up shutdown-backup-sessions",
5003 * and it's not a backup server and its effective weight is > 0,
5004 * then it can accept new connections, so we shut down all streams
5005 * on all backup servers.
5006 */
5007 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
5008 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
5009 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
5010
5011 /* check if we can handle some connections queued at the proxy. We
5012 * will take as many as we can handle.
5013 */
5014 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005015 }
5016 else if (s->next_admin & SRV_ADMF_MAINT) {
5017 /* remaining in maintenance mode, let's inform precisely about the
5018 * situation.
5019 */
5020 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5021 tmptrash = alloc_trash_chunk();
5022 if (tmptrash) {
5023 chunk_printf(tmptrash,
5024 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
5025 s->flags & SRV_F_BACKUP ? "Backup " : "",
5026 s->proxy->id, s->id);
5027
5028 if (s->track) /* normally it's mandatory here */
5029 chunk_appendf(tmptrash, " via %s/%s",
5030 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005031 ha_warning("%s.\n", tmptrash->area);
5032 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5033 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005034 free_trash_chunk(tmptrash);
5035 tmptrash = NULL;
5036 }
5037 }
5038 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5039 tmptrash = alloc_trash_chunk();
5040 if (tmptrash) {
5041 chunk_printf(tmptrash,
5042 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
5043 s->flags & SRV_F_BACKUP ? "Backup " : "",
5044 s->proxy->id, s->id, s->hostname);
5045
5046 if (s->track) /* normally it's mandatory here */
5047 chunk_appendf(tmptrash, " via %s/%s",
5048 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005049 ha_warning("%s.\n", tmptrash->area);
5050 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5051 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005052 free_trash_chunk(tmptrash);
5053 tmptrash = NULL;
5054 }
5055 }
5056 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5057 tmptrash = alloc_trash_chunk();
5058 if (tmptrash) {
5059 chunk_printf(tmptrash,
5060 "%sServer %s/%s remains in forced maintenance",
5061 s->flags & SRV_F_BACKUP ? "Backup " : "",
5062 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005063 ha_warning("%s.\n", tmptrash->area);
5064 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5065 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005066 free_trash_chunk(tmptrash);
5067 tmptrash = NULL;
5068 }
5069 }
5070 /* don't report anything when leaving drain mode and remaining in maintenance */
5071
5072 s->cur_admin = s->next_admin;
5073 }
5074
5075 if (!(s->next_admin & SRV_ADMF_MAINT)) {
5076 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
5077 /* drain state is applied only if not yet in maint */
5078
5079 s->last_change = now.tv_sec;
5080 if (px->lbprm.set_server_status_down)
5081 px->lbprm.set_server_status_down(s);
5082
5083 /* we might have streams queued on this server and waiting for
5084 * a connection. Those which are redispatchable will be queued
5085 * to another server or to the proxy itself.
5086 */
5087 xferred = pendconn_redistribute(s);
5088
5089 tmptrash = alloc_trash_chunk();
5090 if (tmptrash) {
5091 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
5092 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5093 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5094
5095 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
5096
5097 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005098 ha_warning("%s.\n", tmptrash->area);
5099 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5100 tmptrash->area);
5101 send_email_alert(s, LOG_NOTICE, "%s",
5102 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005103 }
5104 free_trash_chunk(tmptrash);
5105 tmptrash = NULL;
5106 }
5107
5108 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5109 set_backend_down(s->proxy);
5110 }
5111 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
5112 /* OK completely leaving drain mode */
5113 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
5114 if (s->proxy->last_change < now.tv_sec) // ignore negative times
5115 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
5116 s->proxy->last_change = now.tv_sec;
5117 }
5118
5119 if (s->last_change < now.tv_sec) // ignore negative times
5120 s->down_time += now.tv_sec - s->last_change;
5121 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005122 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005123
5124 tmptrash = alloc_trash_chunk();
5125 if (tmptrash) {
5126 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5127 chunk_printf(tmptrash,
5128 "%sServer %s/%s is %s (leaving forced drain)",
5129 s->flags & SRV_F_BACKUP ? "Backup " : "",
5130 s->proxy->id, s->id,
5131 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5132 }
5133 else {
5134 chunk_printf(tmptrash,
5135 "%sServer %s/%s is %s (leaving drain)",
5136 s->flags & SRV_F_BACKUP ? "Backup " : "",
5137 s->proxy->id, s->id,
5138 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5139 if (s->track) /* normally it's mandatory here */
5140 chunk_appendf(tmptrash, " via %s/%s",
5141 s->track->proxy->id, s->track->id);
5142 }
5143
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005144 ha_warning("%s.\n", tmptrash->area);
5145 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5146 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005147 free_trash_chunk(tmptrash);
5148 tmptrash = NULL;
5149 }
5150
5151 /* now propagate the status change to any LB algorithms */
5152 if (px->lbprm.update_server_eweight)
5153 px->lbprm.update_server_eweight(s);
5154 else if (srv_willbe_usable(s)) {
5155 if (px->lbprm.set_server_status_up)
5156 px->lbprm.set_server_status_up(s);
5157 }
5158 else {
5159 if (px->lbprm.set_server_status_down)
5160 px->lbprm.set_server_status_down(s);
5161 }
5162 }
5163 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
5164 /* remaining in drain mode after removing one of its flags */
5165
5166 tmptrash = alloc_trash_chunk();
5167 if (tmptrash) {
5168 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5169 chunk_printf(tmptrash,
5170 "%sServer %s/%s is leaving forced drain but remains in drain mode",
5171 s->flags & SRV_F_BACKUP ? "Backup " : "",
5172 s->proxy->id, s->id);
5173
5174 if (s->track) /* normally it's mandatory here */
5175 chunk_appendf(tmptrash, " via %s/%s",
5176 s->track->proxy->id, s->track->id);
5177 }
5178 else {
5179 chunk_printf(tmptrash,
5180 "%sServer %s/%s remains in forced drain mode",
5181 s->flags & SRV_F_BACKUP ? "Backup " : "",
5182 s->proxy->id, s->id);
5183 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005184 ha_warning("%s.\n", tmptrash->area);
5185 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5186 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005187 free_trash_chunk(tmptrash);
5188 tmptrash = NULL;
5189 }
5190
5191 /* commit new admin status */
5192
5193 s->cur_admin = s->next_admin;
5194 }
5195 }
5196
5197 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02005198 *s->adm_st_chg_cause = 0;
5199}
Emeric Brun64cc49c2017-10-03 14:46:45 +02005200
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005201struct task *srv_cleanup_toremove_connections(struct task *task, void *context, unsigned short state)
5202{
5203 struct connection *conn;
5204
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005205 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005206 struct connection *, list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02005207 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005208 }
5209
5210 return task;
5211}
5212
Olivier Houchardff1d0922020-06-29 20:15:59 +02005213/* Move toremove_nb connections from idle_list to toremove_list, -1 means
5214 * moving them all.
5215 * Returns the number of connections moved.
5216 */
5217static int srv_migrate_conns_to_remove(struct mt_list *idle_list, struct mt_list *toremove_list, int toremove_nb)
5218{
5219 struct mt_list *elt1, elt2;
5220 struct connection *conn;
5221 int i = 0;
5222
5223 mt_list_for_each_entry_safe(conn, idle_list, list, elt1, elt2) {
5224 if (toremove_nb != -1 && i >= toremove_nb)
5225 break;
5226 MT_LIST_DEL_SAFE_NOINIT(elt1);
Willy Tarreaude4db172020-07-10 08:10:29 +02005227 MT_LIST_ADDQ(toremove_list, &conn->list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02005228 i++;
5229 }
5230 return i;
5231}
William Dauchy6318d332020-05-02 21:52:36 +02005232/* cleanup connections for a given server
5233 * might be useful when going on forced maintenance or live changing ip/port
5234 */
William Dauchy707ad322020-05-04 13:52:40 +02005235static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02005236{
William Dauchy6318d332020-05-02 21:52:36 +02005237 int did_remove;
5238 int i;
William Dauchy6318d332020-05-02 21:52:36 +02005239
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005240 /* check all threads starting with ours */
William Dauchy6318d332020-05-02 21:52:36 +02005241 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005242 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02005243 did_remove = 0;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005244 if (srv_migrate_conns_to_remove(&srv->idle_conns[i], &idle_conns[i].toremove_conns, -1) > 0)
William Dauchy6318d332020-05-02 21:52:36 +02005245 did_remove = 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005246 if (srv_migrate_conns_to_remove(&srv->safe_conns[i], &idle_conns[i].toremove_conns, -1) > 0)
5247 did_remove = 1;
William Dauchy6318d332020-05-02 21:52:36 +02005248 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005249 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005250
5251 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5252 break;
William Dauchy6318d332020-05-02 21:52:36 +02005253 }
5254 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5255}
5256
Willy Tarreau980855b2019-02-07 14:59:29 +01005257struct task *srv_cleanup_idle_connections(struct task *task, void *context, unsigned short state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005258{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005259 struct server *srv;
5260 struct eb32_node *eb;
5261 int i;
5262 unsigned int next_wakeup;
5263 int need_wakeup = 0;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005264
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005265 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
5266 while (1) {
5267 int srv_is_empty = 1;
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005268 int exceed_conns;
5269 int to_kill;
5270 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005271
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005272 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
5273 if (!eb) {
5274 /* we might have reached the end of the tree, typically because
5275 * <now_ms> is in the first half and we're first scanning the last
5276 * half. Let's loop back to the beginning of the tree now.
5277 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005278
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005279 eb = eb32_first(&idle_conn_srv);
5280 if (likely(!eb))
5281 break;
5282 }
5283 if (tick_is_lt(now_ms, eb->key)) {
5284 /* timer not expired yet, revisit it later */
5285 next_wakeup = eb->key;
5286 need_wakeup = 1;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005287 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005288 }
5289 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005290
5291 /* Calculate how many idle connections we want to kill :
5292 * we want to remove half the difference between the total
5293 * of established connections (used or idle) and the max
5294 * number of used connections.
5295 */
5296 curr_idle = srv->curr_idle_conns;
5297 if (curr_idle == 0)
5298 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005299 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005300 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02005301
5302 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns + 1) / 2;
5303 if (srv->est_need_conns < srv->max_used_conns)
5304 srv->est_need_conns = srv->max_used_conns;
5305
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005306 srv->max_used_conns = srv->curr_used_conns;
5307
Willy Tarreau18ed7892020-07-02 19:05:30 +02005308 if (exceed_conns <= 0)
5309 goto remove;
5310
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005311 /* check all threads starting with ours */
5312 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005313 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005314 int j;
5315 int did_remove = 0;
5316
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005317 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
5318 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005319
5320 j = srv_migrate_conns_to_remove(&srv->idle_conns[i], &idle_conns[i].toremove_conns, max_conn);
5321 if (j > 0)
5322 did_remove = 1;
5323 if (max_conn - j > 0 &&
5324 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 +01005325 did_remove = 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02005326
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005327 if (did_remove && max_conn < srv->curr_idle_thr[i])
5328 srv_is_empty = 0;
5329 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02005330 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02005331
5332 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
5333 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005334 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02005335remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005336 eb32_delete(&srv->idle_node);
5337 if (!srv_is_empty) {
5338 /* There are still more idle connections, add the
5339 * server back in the tree.
5340 */
5341 srv->idle_node.key = tick_add(srv->pool_purge_delay,
5342 now_ms);
5343 eb32_insert(&idle_conn_srv, &srv->idle_node);
5344 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005345 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005346 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5347
5348 if (need_wakeup)
5349 task->expire = next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005350 else
5351 task->expire = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005352
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005353 return task;
5354}
Olivier Houchard88698d92019-04-16 19:07:22 +02005355
Willy Tarreau76cc6992020-07-01 18:49:24 +02005356/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
5357static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
5358 struct proxy *defpx, const char *file, int line,
5359 char **err)
5360{
5361 if (too_many_args(1, args, err, NULL))
5362 return -1;
5363
5364 if (strcmp(args[1], "on") == 0)
5365 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
5366 else if (strcmp(args[1], "off") == 0)
5367 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
5368 else {
5369 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
5370 return -1;
5371 }
5372 return 0;
5373}
5374
Olivier Houchard88698d92019-04-16 19:07:22 +02005375/* config parser for global "tune.pool-{low,high}-fd-ratio" */
5376static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
5377 struct proxy *defpx, const char *file, int line,
5378 char **err)
5379{
5380 int arg = -1;
5381
5382 if (too_many_args(1, args, err, NULL))
5383 return -1;
5384
5385 if (*(args[1]) != 0)
5386 arg = atoi(args[1]);
5387
5388 if (arg < 0 || arg > 100) {
5389 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
5390 return -1;
5391 }
5392
5393 if (args[0][10] == 'h')
5394 global.tune.pool_high_ratio = arg;
5395 else
5396 global.tune.pool_low_ratio = arg;
5397 return 0;
5398}
5399
5400/* config keyword parsers */
5401static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02005402 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02005403 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
5404 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
5405 { 0, NULL, NULL }
5406}};
5407
5408INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
5409
Baptiste Assmanna68ca962015-04-14 01:15:08 +02005410/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02005411 * Local variables:
5412 * c-indent-level: 8
5413 * c-basic-offset: 8
5414 * End:
5415 */