blob: 07a6603a35096f4f88f484ae3557430e5e88169c [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 Tarreau272adea2014-03-31 10:39:59 +020014#include <ctype.h>
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020015#include <errno.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020016
Olivier Houchard4e694042017-03-14 20:01:29 +010017#include <import/xxhash.h>
18
Willy Tarreau272adea2014-03-31 10:39:59 +020019#include <common/cfgparse.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020020#include <common/config.h>
Willy Tarreaudff55432012-10-10 17:51:05 +020021#include <common/errors.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010022#include <common/namespace.h>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020023#include <common/time.h>
24
William Lallemand222baf22016-11-19 02:00:33 +010025#include <types/applet.h>
26#include <types/cli.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020027#include <types/global.h>
Willy Tarreau21b069d2016-11-23 17:15:08 +010028#include <types/cli.h>
Baptiste Assmanna68ca962015-04-14 01:15:08 +020029#include <types/dns.h>
William Lallemand222baf22016-11-19 02:00:33 +010030#include <types/stats.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020031
William Lallemand222baf22016-11-19 02:00:33 +010032#include <proto/applet.h>
33#include <proto/cli.h>
Simon Hormanb1900d52015-01-30 11:22:54 +090034#include <proto/checks.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020035#include <proto/port_range.h>
36#include <proto/protocol.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020037#include <proto/queue.h>
Frédéric Lécaille9a146de2017-03-20 14:54:41 +010038#include <proto/sample.h>
Willy Tarreauec6c5df2008-07-15 00:22:45 +020039#include <proto/server.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020040#include <proto/stream.h>
William Lallemand222baf22016-11-19 02:00:33 +010041#include <proto/stream_interface.h>
42#include <proto/stats.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020043#include <proto/task.h>
Baptiste Assmanna68ca962015-04-14 01:15:08 +020044#include <proto/dns.h>
David Carlier6f182082017-04-03 21:58:04 +010045#include <netinet/tcp.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020046
Emeric Brun64cc49c2017-10-03 14:46:45 +020047struct list updated_servers = LIST_HEAD_INIT(updated_servers);
Christopher Faulet9dcf9b62017-11-13 10:34:01 +010048__decl_hathreads(HA_SPINLOCK_T updated_servers_lock);
Christopher Faulet5d42e092017-10-16 12:00:40 +020049
50static void srv_register_update(struct server *srv);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020051static void srv_update_state(struct server *srv, int version, char **params);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010052static int srv_apply_lastaddr(struct server *srv, int *err_code);
Olivier Houchardd16bfe62017-10-31 15:21:19 +010053static int srv_set_fqdn(struct server *srv, const char *fqdn, int dns_locked);
Willy Tarreaubaaee002006-06-26 02:48:02 +020054
Willy Tarreau21faa912012-10-10 08:27:36 +020055/* List head of all known server keywords */
56static struct srv_kw_list srv_keywords = {
57 .list = LIST_HEAD_INIT(srv_keywords.list)
58};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020059
Simon Hormana3608442013-11-01 16:46:15 +090060int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020061{
Emeric Brun52a91d32017-08-31 14:41:55 +020062 if ((s->cur_state != SRV_ST_STOPPED) && s->last_change < now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020063 return s->down_time;
64
65 return now.tv_sec - s->last_change + s->down_time;
66}
Willy Tarreaubaaee002006-06-26 02:48:02 +020067
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050068int srv_lastsession(const struct server *s)
69{
70 if (s->counters.last_sess)
71 return now.tv_sec - s->counters.last_sess;
72
73 return -1;
74}
75
Simon Horman4a741432013-02-23 15:35:38 +090076int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020077{
Simon Horman4a741432013-02-23 15:35:38 +090078 const struct server *s = check->server;
79
Willy Tarreauff5ae352013-12-11 20:36:34 +010080 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090081 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010082
Emeric Brun52a91d32017-08-31 14:41:55 +020083 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +090084 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010085
Simon Horman4a741432013-02-23 15:35:38 +090086 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010087}
88
Olivier Houcharde9bad0a2018-01-17 17:39:34 +010089/*
90 * Check that we did not get a hash collision.
91 * Unlikely, but it can happen.
92 */
93static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +010094{
95 struct proxy *p = s->proxy;
96 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +010097
98 for (tmpserv = p->srv; tmpserv != NULL;
99 tmpserv = tmpserv->next) {
100 if (tmpserv == s)
101 continue;
102 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
103 continue;
104 if (tmpserv->cookie &&
105 strcmp(tmpserv->cookie, s->cookie) == 0) {
106 ha_warning("We generated two equal cookies for two different servers.\n"
107 "Please change the secret key for '%s'.\n",
108 s->proxy->id);
109 }
110 }
111
112}
113
114void srv_set_dyncookie(struct server *s)
115{
116 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100117 char *tmpbuf;
118 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100119 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100120 size_t buffer_len;
121 int addr_len;
122 int port;
123
124 if ((s->flags & SRV_F_COOKIESET) ||
125 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
126 s->proxy->dyncookie_key == NULL)
127 return;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100128 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100129
130 if (s->addr.ss_family != AF_INET &&
131 s->addr.ss_family != AF_INET6)
132 return;
133 /*
134 * Buffer to calculate the cookie value.
135 * The buffer contains the secret key + the server IP address
136 * + the TCP port.
137 */
138 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
139 /*
140 * The TCP port should use only 2 bytes, but is stored in
141 * an unsigned int in struct server, so let's use 4, to be
142 * on the safe side.
143 */
144 buffer_len = key_len + addr_len + 4;
145 tmpbuf = trash.str;
146 memcpy(tmpbuf, p->dyncookie_key, key_len);
147 memcpy(&(tmpbuf[key_len]),
148 s->addr.ss_family == AF_INET ?
149 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
150 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
151 addr_len);
152 /*
153 * Make sure it's the same across all the load balancers,
154 * no matter their endianness.
155 */
156 port = htonl(s->svc_port);
157 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
158 hash_value = XXH64(tmpbuf, buffer_len, 0);
159 memprintf(&s->cookie, "%016llx", hash_value);
160 if (!s->cookie)
161 return;
162 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100163
164 /* Don't bother checking if the dyncookie is duplicated if
165 * the server is marked as "disabled", maybe it doesn't have
166 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100167 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100168 if (!(s->next_admin & SRV_ADMF_FMAINT))
169 srv_check_for_dup_dyncookie(s);
Olivier Houchard4e694042017-03-14 20:01:29 +0100170}
171
Willy Tarreau21faa912012-10-10 08:27:36 +0200172/*
173 * Registers the server keyword list <kwl> as a list of valid keywords for next
174 * parsing sessions.
175 */
176void srv_register_keywords(struct srv_kw_list *kwl)
177{
178 LIST_ADDQ(&srv_keywords.list, &kwl->list);
179}
180
181/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
182 * keyword is found with a NULL ->parse() function, then an attempt is made to
183 * find one with a valid ->parse() function. This way it is possible to declare
184 * platform-dependant, known keywords as NULL, then only declare them as valid
185 * if some options are met. Note that if the requested keyword contains an
186 * opening parenthesis, everything from this point is ignored.
187 */
188struct srv_kw *srv_find_kw(const char *kw)
189{
190 int index;
191 const char *kwend;
192 struct srv_kw_list *kwl;
193 struct srv_kw *ret = NULL;
194
195 kwend = strchr(kw, '(');
196 if (!kwend)
197 kwend = kw + strlen(kw);
198
199 list_for_each_entry(kwl, &srv_keywords.list, list) {
200 for (index = 0; kwl->kw[index].kw != NULL; index++) {
201 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
202 kwl->kw[index].kw[kwend-kw] == 0) {
203 if (kwl->kw[index].parse)
204 return &kwl->kw[index]; /* found it !*/
205 else
206 ret = &kwl->kw[index]; /* may be OK */
207 }
208 }
209 }
210 return ret;
211}
212
213/* Dumps all registered "server" keywords to the <out> string pointer. The
214 * unsupported keywords are only dumped if their supported form was not
215 * found.
216 */
217void srv_dump_kws(char **out)
218{
219 struct srv_kw_list *kwl;
220 int index;
221
222 *out = NULL;
223 list_for_each_entry(kwl, &srv_keywords.list, list) {
224 for (index = 0; kwl->kw[index].kw != NULL; index++) {
225 if (kwl->kw[index].parse ||
226 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
227 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
228 kwl->scope,
229 kwl->kw[index].kw,
230 kwl->kw[index].skip ? " <arg>" : "",
231 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
232 kwl->kw[index].parse ? "" : " (not supported)");
233 }
234 }
235 }
236}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100237
Frédéric Lécaille6e5e0d82017-03-20 16:30:18 +0100238/* Parse the "addr" server keyword */
239static int srv_parse_addr(char **args, int *cur_arg,
240 struct proxy *curproxy, struct server *newsrv, char **err)
241{
242 char *errmsg, *arg;
243 struct sockaddr_storage *sk;
244 int port1, port2;
245 struct protocol *proto;
246
247 errmsg = NULL;
248 arg = args[*cur_arg + 1];
249
250 if (!*arg) {
251 memprintf(err, "'%s' expects <ipv4|ipv6> as argument.\n", args[*cur_arg]);
252 goto err;
253 }
254
255 sk = str2sa_range(arg, NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
256 if (!sk) {
257 memprintf(err, "'%s' : %s", args[*cur_arg], errmsg);
258 goto err;
259 }
260
261 proto = protocol_by_family(sk->ss_family);
262 if (!proto || !proto->connect) {
263 memprintf(err, "'%s %s' : connect() not supported for this address family.\n",
264 args[*cur_arg], arg);
265 goto err;
266 }
267
268 if (port1 != port2) {
269 memprintf(err, "'%s' : port ranges and offsets are not allowed in '%s'\n",
270 args[*cur_arg], arg);
271 goto err;
272 }
273
274 newsrv->check.addr = newsrv->agent.addr = *sk;
275 newsrv->flags |= SRV_F_CHECKADDR;
276 newsrv->flags |= SRV_F_AGENTADDR;
277
278 return 0;
279
280 err:
281 free(errmsg);
282 return ERR_ALERT | ERR_FATAL;
283}
284
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +0100285/* Parse the "agent-check" server keyword */
286static int srv_parse_agent_check(char **args, int *cur_arg,
287 struct proxy *curproxy, struct server *newsrv, char **err)
288{
289 newsrv->do_agent = 1;
290 return 0;
291}
292
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100293/* Parse the "backup" server keyword */
294static int srv_parse_backup(char **args, int *cur_arg,
295 struct proxy *curproxy, struct server *newsrv, char **err)
296{
297 newsrv->flags |= SRV_F_BACKUP;
298 return 0;
299}
300
Frédéric Lécaille65aa3562017-03-14 11:20:13 +0100301/* Parse the "check" server keyword */
302static int srv_parse_check(char **args, int *cur_arg,
303 struct proxy *curproxy, struct server *newsrv, char **err)
304{
305 newsrv->do_check = 1;
306 return 0;
307}
308
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100309/* Parse the "check-send-proxy" server keyword */
310static int srv_parse_check_send_proxy(char **args, int *cur_arg,
311 struct proxy *curproxy, struct server *newsrv, char **err)
312{
313 newsrv->check.send_proxy = 1;
314 return 0;
315}
316
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100317/* Parse the "cookie" server keyword */
318static int srv_parse_cookie(char **args, int *cur_arg,
319 struct proxy *curproxy, struct server *newsrv, char **err)
320{
321 char *arg;
322
323 arg = args[*cur_arg + 1];
324 if (!*arg) {
325 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
326 return ERR_ALERT | ERR_FATAL;
327 }
328
329 free(newsrv->cookie);
330 newsrv->cookie = strdup(arg);
331 newsrv->cklen = strlen(arg);
332 newsrv->flags |= SRV_F_COOKIESET;
333 return 0;
334}
335
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100336/* Parse the "disabled" server keyword */
337static int srv_parse_disabled(char **args, int *cur_arg,
338 struct proxy *curproxy, struct server *newsrv, char **err)
339{
Emeric Brun52a91d32017-08-31 14:41:55 +0200340 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
341 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100342 newsrv->check.state |= CHK_ST_PAUSED;
343 newsrv->check.health = 0;
344 return 0;
345}
346
347/* Parse the "enabled" server keyword */
348static int srv_parse_enabled(char **args, int *cur_arg,
349 struct proxy *curproxy, struct server *newsrv, char **err)
350{
Emeric Brun52a91d32017-08-31 14:41:55 +0200351 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
352 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100353 newsrv->check.state &= ~CHK_ST_PAUSED;
354 newsrv->check.health = newsrv->check.rise;
355 return 0;
356}
357
Willy Tarreaudff55432012-10-10 17:51:05 +0200358/* parse the "id" server keyword */
359static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
360{
361 struct eb32_node *node;
362
363 if (!*args[*cur_arg + 1]) {
364 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
365 return ERR_ALERT | ERR_FATAL;
366 }
367
368 newsrv->puid = atol(args[*cur_arg + 1]);
369 newsrv->conf.id.key = newsrv->puid;
370
371 if (newsrv->puid <= 0) {
372 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
373 return ERR_ALERT | ERR_FATAL;
374 }
375
376 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
377 if (node) {
378 struct server *target = container_of(node, struct server, conf.id);
379 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
380 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
381 target->id);
382 return ERR_ALERT | ERR_FATAL;
383 }
384
385 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200386 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200387 return 0;
388}
389
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100390/* Parse the "namespace" server keyword */
391static int srv_parse_namespace(char **args, int *cur_arg,
392 struct proxy *curproxy, struct server *newsrv, char **err)
393{
394#ifdef CONFIG_HAP_NS
395 char *arg;
396
397 arg = args[*cur_arg + 1];
398 if (!*arg) {
399 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
400 return ERR_ALERT | ERR_FATAL;
401 }
402
403 if (!strcmp(arg, "*")) {
404 /* Use the namespace associated with the connection (if present). */
405 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
406 return 0;
407 }
408
409 /*
410 * As this parser may be called several times for the same 'default-server'
411 * object, or for a new 'server' instance deriving from a 'default-server'
412 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
413 */
414 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
415
416 newsrv->netns = netns_store_lookup(arg, strlen(arg));
417 if (!newsrv->netns)
418 newsrv->netns = netns_store_insert(arg);
419
420 if (!newsrv->netns) {
421 memprintf(err, "Cannot open namespace '%s'", arg);
422 return ERR_ALERT | ERR_FATAL;
423 }
424
425 return 0;
426#else
427 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
428 return ERR_ALERT | ERR_FATAL;
429#endif
430}
431
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +0100432/* Parse the "no-agent-check" server keyword */
433static int srv_parse_no_agent_check(char **args, int *cur_arg,
434 struct proxy *curproxy, struct server *newsrv, char **err)
435{
436 free_check(&newsrv->agent);
437 newsrv->agent.inter = 0;
438 newsrv->agent.port = 0;
439 newsrv->agent.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED & ~CHK_ST_AGENT;
440 newsrv->do_agent = 0;
441 return 0;
442}
443
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100444/* Parse the "no-backup" server keyword */
445static int srv_parse_no_backup(char **args, int *cur_arg,
446 struct proxy *curproxy, struct server *newsrv, char **err)
447{
448 newsrv->flags &= ~SRV_F_BACKUP;
449 return 0;
450}
451
Frédéric Lécaille65aa3562017-03-14 11:20:13 +0100452/* Parse the "no-check" server keyword */
453static int srv_parse_no_check(char **args, int *cur_arg,
454 struct proxy *curproxy, struct server *newsrv, char **err)
455{
456 free_check(&newsrv->check);
457 newsrv->check.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED;
458 newsrv->do_check = 0;
459 return 0;
460}
461
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100462/* Parse the "no-check-send-proxy" server keyword */
463static int srv_parse_no_check_send_proxy(char **args, int *cur_arg,
464 struct proxy *curproxy, struct server *newsrv, char **err)
465{
466 newsrv->check.send_proxy = 0;
467 return 0;
468}
469
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100470/* Disable server PROXY protocol flags. */
471static int inline srv_disable_pp_flags(struct server *srv, unsigned int flags)
472{
473 srv->pp_opts &= ~flags;
474 return 0;
475}
476
477/* Parse the "no-send-proxy" server keyword */
478static int srv_parse_no_send_proxy(char **args, int *cur_arg,
479 struct proxy *curproxy, struct server *newsrv, char **err)
480{
481 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
482}
483
484/* Parse the "no-send-proxy-v2" server keyword */
485static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
486 struct proxy *curproxy, struct server *newsrv, char **err)
487{
488 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
489}
490
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100491/* Parse the "non-stick" server keyword */
492static int srv_parse_non_stick(char **args, int *cur_arg,
493 struct proxy *curproxy, struct server *newsrv, char **err)
494{
495 newsrv->flags |= SRV_F_NON_STICK;
496 return 0;
497}
498
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100499/* Enable server PROXY protocol flags. */
500static int inline srv_enable_pp_flags(struct server *srv, unsigned int flags)
501{
502 srv->pp_opts |= flags;
503 return 0;
504}
505
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100506/* Parse the "observe" server keyword */
507static int srv_parse_observe(char **args, int *cur_arg,
508 struct proxy *curproxy, struct server *newsrv, char **err)
509{
510 char *arg;
511
512 arg = args[*cur_arg + 1];
513 if (!*arg) {
514 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
515 return ERR_ALERT | ERR_FATAL;
516 }
517
518 if (!strcmp(arg, "none")) {
519 newsrv->observe = HANA_OBS_NONE;
520 }
521 else if (!strcmp(arg, "layer4")) {
522 newsrv->observe = HANA_OBS_LAYER4;
523 }
524 else if (!strcmp(arg, "layer7")) {
525 if (curproxy->mode != PR_MODE_HTTP) {
526 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
527 return ERR_ALERT;
528 }
529 newsrv->observe = HANA_OBS_LAYER7;
530 }
531 else {
532 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
533 "but got '%s'\n", args[*cur_arg], arg);
534 return ERR_ALERT | ERR_FATAL;
535 }
536
537 return 0;
538}
539
Frédéric Lécaille16186232017-03-14 16:42:49 +0100540/* Parse the "redir" server keyword */
541static int srv_parse_redir(char **args, int *cur_arg,
542 struct proxy *curproxy, struct server *newsrv, char **err)
543{
544 char *arg;
545
546 arg = args[*cur_arg + 1];
547 if (!*arg) {
548 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
549 return ERR_ALERT | ERR_FATAL;
550 }
551
552 free(newsrv->rdr_pfx);
553 newsrv->rdr_pfx = strdup(arg);
554 newsrv->rdr_len = strlen(arg);
555
556 return 0;
557}
558
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100559/* Parse the "send-proxy" server keyword */
560static int srv_parse_send_proxy(char **args, int *cur_arg,
561 struct proxy *curproxy, struct server *newsrv, char **err)
562{
563 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
564}
565
566/* Parse the "send-proxy-v2" server keyword */
567static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
568 struct proxy *curproxy, struct server *newsrv, char **err)
569{
570 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
571}
572
Frédéric Lécailledba97072017-03-17 15:33:50 +0100573
574/* Parse the "source" server keyword */
575static int srv_parse_source(char **args, int *cur_arg,
576 struct proxy *curproxy, struct server *newsrv, char **err)
577{
578 char *errmsg;
579 int port_low, port_high;
580 struct sockaddr_storage *sk;
581 struct protocol *proto;
582
583 errmsg = NULL;
584
585 if (!*args[*cur_arg + 1]) {
586 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
587 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
588 goto err;
589 }
590
591 /* 'sk' is statically allocated (no need to be freed). */
592 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, &errmsg, NULL, NULL, 1);
593 if (!sk) {
594 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
595 goto err;
596 }
597
598 proto = protocol_by_family(sk->ss_family);
599 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100600 ha_alert("'%s %s' : connect() not supported for this address family.\n",
601 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100602 goto err;
603 }
604
605 newsrv->conn_src.opts |= CO_SRC_BIND;
606 newsrv->conn_src.source_addr = *sk;
607
608 if (port_low != port_high) {
609 int i;
610
611 if (!port_low || !port_high) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100612 ha_alert("'%s' does not support port offsets (found '%s').\n",
613 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100614 goto err;
615 }
616
617 if (port_low <= 0 || port_low > 65535 ||
618 port_high <= 0 || port_high > 65535 ||
619 port_low > port_high) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100620 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 +0100621 goto err;
622 }
623 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
624 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
625 newsrv->conn_src.sport_range->ports[i] = port_low + i;
626 }
627
628 *cur_arg += 2;
629 while (*(args[*cur_arg])) {
630 if (!strcmp(args[*cur_arg], "usesrc")) { /* address to use outside */
631#if defined(CONFIG_HAP_TRANSPARENT)
632 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100633 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
634 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100635 goto err;
636 }
637 if (!strcmp(args[*cur_arg + 1], "client")) {
638 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
639 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
640 }
641 else if (!strcmp(args[*cur_arg + 1], "clientip")) {
642 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
643 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
644 }
645 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
646 char *name, *end;
647
648 name = args[*cur_arg + 1] + 7;
649 while (isspace(*name))
650 name++;
651
652 end = name;
653 while (*end && !isspace(*end) && *end != ',' && *end != ')')
654 end++;
655
656 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
657 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
658 free(newsrv->conn_src.bind_hdr_name);
659 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
660 newsrv->conn_src.bind_hdr_len = end - name;
661 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
662 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
663 newsrv->conn_src.bind_hdr_occ = -1;
664
665 /* now look for an occurrence number */
666 while (isspace(*end))
667 end++;
668 if (*end == ',') {
669 end++;
670 name = end;
671 if (*end == '-')
672 end++;
673 while (isdigit((int)*end))
674 end++;
675 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
676 }
677
678 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100679 ha_alert("usesrc hdr_ip(name,num) does not support negative"
680 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100681 goto err;
682 }
683 }
684 else {
685 struct sockaddr_storage *sk;
686 int port1, port2;
687
688 /* 'sk' is statically allocated (no need to be freed). */
689 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
690 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100691 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100692 goto err;
693 }
694
695 proto = protocol_by_family(sk->ss_family);
696 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100697 ha_alert("'%s %s' : connect() not supported for this address family.\n",
698 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100699 goto err;
700 }
701
702 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100703 ha_alert("'%s' : port ranges and offsets are not allowed in '%s'\n",
704 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100705 goto err;
706 }
707 newsrv->conn_src.tproxy_addr = *sk;
708 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
709 }
710 global.last_checks |= LSTCHK_NETADM;
711 *cur_arg += 2;
712 continue;
713#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100714 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 +0100715 goto err;
716#endif /* defined(CONFIG_HAP_TRANSPARENT) */
717 } /* "usesrc" */
718
719 if (!strcmp(args[*cur_arg], "interface")) { /* specifically bind to this interface */
720#ifdef SO_BINDTODEVICE
721 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100722 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100723 goto err;
724 }
725 free(newsrv->conn_src.iface_name);
726 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
727 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
728 global.last_checks |= LSTCHK_NETADM;
729#else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100730 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100731 goto err;
732#endif
733 *cur_arg += 2;
734 continue;
735 }
736 /* this keyword in not an option of "source" */
737 break;
738 } /* while */
739
740 return 0;
741
742 err:
743 free(errmsg);
744 return ERR_ALERT | ERR_FATAL;
745}
746
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100747/* Parse the "stick" server keyword */
748static int srv_parse_stick(char **args, int *cur_arg,
749 struct proxy *curproxy, struct server *newsrv, char **err)
750{
751 newsrv->flags &= ~SRV_F_NON_STICK;
752 return 0;
753}
754
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100755/* Parse the "track" server keyword */
756static int srv_parse_track(char **args, int *cur_arg,
757 struct proxy *curproxy, struct server *newsrv, char **err)
758{
759 char *arg;
760
761 arg = args[*cur_arg + 1];
762 if (!*arg) {
763 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
764 return ERR_ALERT | ERR_FATAL;
765 }
766
767 free(newsrv->trackit);
768 newsrv->trackit = strdup(arg);
769
770 return 0;
771}
772
Frédéric Lécailledba97072017-03-17 15:33:50 +0100773
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200774/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200775 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200776 * shutdown.
777 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200778void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200779{
Willy Tarreau87b09662015-04-03 00:22:06 +0200780 struct stream *stream, *stream_bck;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200781
Willy Tarreau87b09662015-04-03 00:22:06 +0200782 list_for_each_entry_safe(stream, stream_bck, &srv->actconns, by_srv)
783 if (stream->srv_conn == srv)
784 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200785}
786
787/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200788 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200789 * the reason for the shutdown.
790 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200791void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200792{
793 struct server *srv;
794
795 for (srv = px->srv; srv != NULL; srv = srv->next)
796 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200797 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200798}
799
Willy Tarreaubda92272014-05-20 21:55:30 +0200800/* Appends some information to a message string related to a server going UP or
801 * DOWN. If both <forced> and <reason> are null and the server tracks another
802 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +0200803 * If <check> is non-null, an entire string describing the check result will be
804 * appended after a comma and a space (eg: to report some information from the
805 * check that changed the state). In the other case, the string will be built
806 * using the check results stored into the struct server if present.
807 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +0200808 * provided.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200809 */
Emeric Brun5a133512017-10-19 14:42:30 +0200810void srv_append_status(struct chunk *msg, struct server *s, struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200811{
Emeric Brun5a133512017-10-19 14:42:30 +0200812 short status = s->op_st_chg.status;
813 short code = s->op_st_chg.code;
814 long duration = s->op_st_chg.duration;
815 char *desc = s->op_st_chg.reason;
816
817 if (check) {
818 status = check->status;
819 code = check->code;
820 duration = check->duration;
821 desc = check->desc;
822 }
823
824 if (status != -1) {
825 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
826
827 if (status >= HCHK_STATUS_L57DATA)
828 chunk_appendf(msg, ", code: %d", code);
829
830 if (desc && *desc) {
831 struct chunk src;
832
833 chunk_appendf(msg, ", info: \"");
834
835 chunk_initlen(&src, desc, 0, strlen(desc));
836 chunk_asciiencode(msg, &src, '"');
837
838 chunk_appendf(msg, "\"");
839 }
840
841 if (duration >= 0)
842 chunk_appendf(msg, ", check duration: %ldms", duration);
843 }
844 else if (desc && *desc) {
845 chunk_appendf(msg, ", %s", desc);
846 }
847 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +0200848 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +0200849 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200850
851 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200852 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200853 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
854 " %d sessions active, %d requeued, %d remaining in queue",
855 s->proxy->srv_act, s->proxy->srv_bck,
856 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
857 s->cur_sess, xferred, s->nbpend);
858 else
859 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
860 " %d sessions requeued, %d total in queue",
861 s->proxy->srv_act, s->proxy->srv_bck,
862 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
863 xferred, s->nbpend);
864 }
865}
866
Emeric Brun5a133512017-10-19 14:42:30 +0200867/* Marks server <s> down, regardless of its checks' statuses. The server is
868 * registered in a list to postpone the counting of the remaining servers on
869 * the proxy and transfers queued streams whenever possible to other servers at
870 * a sync point. Maintenance servers are ignored. It stores the <reason> if
871 * non-null as the reason for going down or the available data from the check
872 * struct to recompute this reason later.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200873 */
Emeric Brun5a133512017-10-19 14:42:30 +0200874void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200875{
876 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200877
Emeric Brun64cc49c2017-10-03 14:46:45 +0200878 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200879 return;
880
Emeric Brun52a91d32017-08-31 14:41:55 +0200881 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +0200882 *s->op_st_chg.reason = 0;
883 s->op_st_chg.status = -1;
884 if (reason) {
885 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
886 }
887 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +0100888 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +0200889 s->op_st_chg.code = check->code;
890 s->op_st_chg.status = check->status;
891 s->op_st_chg.duration = check->duration;
892 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200893
Christopher Faulet5d42e092017-10-16 12:00:40 +0200894 srv_register_update(s);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200895 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100896 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +0200897 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100898 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200899 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200900}
901
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200902/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +0200903 * in maintenance. The server is registered in a list to postpone the counting
904 * of the remaining servers on the proxy and tries to grab requests from the
905 * proxy at a sync point. Maintenance servers are ignored. It stores the
906 * <reason> if non-null as the reason for going down or the available data
907 * from the check struct to recompute this reason later.
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200908 */
Emeric Brun5a133512017-10-19 14:42:30 +0200909void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200910{
911 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200912
Emeric Brun64cc49c2017-10-03 14:46:45 +0200913 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200914 return;
915
Emeric Brun52a91d32017-08-31 14:41:55 +0200916 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200917 return;
918
Emeric Brun52a91d32017-08-31 14:41:55 +0200919 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +0200920 *s->op_st_chg.reason = 0;
921 s->op_st_chg.status = -1;
922 if (reason) {
923 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
924 }
925 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +0100926 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +0200927 s->op_st_chg.code = check->code;
928 s->op_st_chg.status = check->status;
929 s->op_st_chg.duration = check->duration;
930 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200931
Emeric Brun64cc49c2017-10-03 14:46:45 +0200932 if (s->slowstart <= 0)
933 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200934
Christopher Faulet5d42e092017-10-16 12:00:40 +0200935 srv_register_update(s);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200936 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100937 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +0200938 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100939 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200940 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200941}
942
Willy Tarreau8eb77842014-05-21 13:54:57 +0200943/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +0200944 * isn't in maintenance. The server is registered in a list to postpone the
945 * counting of the remaining servers on the proxy and tries to grab requests
946 * from the proxy. Maintenance servers are ignored. It stores the
947 * <reason> if non-null as the reason for going down or the available data
948 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +0200949 * up. Note that it makes use of the trash to build the log strings, so <reason>
950 * must not be placed there.
951 */
Emeric Brun5a133512017-10-19 14:42:30 +0200952void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +0200953{
954 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +0200955
Emeric Brun64cc49c2017-10-03 14:46:45 +0200956 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +0200957 return;
958
Emeric Brun52a91d32017-08-31 14:41:55 +0200959 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +0200960 return;
961
Emeric Brun52a91d32017-08-31 14:41:55 +0200962 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +0200963 *s->op_st_chg.reason = 0;
964 s->op_st_chg.status = -1;
965 if (reason) {
966 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
967 }
968 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +0100969 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +0200970 s->op_st_chg.code = check->code;
971 s->op_st_chg.status = check->status;
972 s->op_st_chg.duration = check->duration;
973 }
Willy Tarreau8eb77842014-05-21 13:54:57 +0200974
Christopher Faulet5d42e092017-10-16 12:00:40 +0200975 srv_register_update(s);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200976 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100977 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +0200978 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +0100979 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200980 }
Willy Tarreau8eb77842014-05-21 13:54:57 +0200981}
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200982
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200983/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
984 * enforce either maint mode or drain mode. It is not allowed to set more than
985 * one flag at once. The equivalent "inherited" flag is propagated to all
986 * tracking servers. Maintenance mode disables health checks (but not agent
987 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +0100988 * is done. If <cause> is non-null, it will be displayed at the end of the log
989 * lines to justify the state change.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200990 */
Willy Tarreau8b428482016-11-07 15:53:43 +0100991void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200992{
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200993 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200994
995 if (!mode)
996 return;
997
998 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +0200999 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001000 return;
1001
Emeric Brun52a91d32017-08-31 14:41:55 +02001002 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001003 if (cause)
1004 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1005
Christopher Faulet5d42e092017-10-16 12:00:40 +02001006 srv_register_update(s);
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001007
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001008 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001009 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1010 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001011 return;
1012
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001013 /* compute the inherited flag to propagate */
1014 if (mode & SRV_ADMF_MAINT)
1015 mode = SRV_ADMF_IMAINT;
1016 else if (mode & SRV_ADMF_DRAIN)
1017 mode = SRV_ADMF_IDRAIN;
1018
Emeric Brun9f0b4582017-10-23 14:39:51 +02001019 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001020 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001021 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001022 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001023 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001024}
1025
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001026/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1027 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1028 * than one flag at once. The equivalent "inherited" flag is propagated to all
1029 * tracking servers. Leaving maintenance mode re-enables health checks. When
1030 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001031 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001032void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001033{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001034 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001035
1036 if (!mode)
1037 return;
1038
1039 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001040 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001041 return;
1042
Emeric Brun52a91d32017-08-31 14:41:55 +02001043 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001044
Christopher Faulet5d42e092017-10-16 12:00:40 +02001045 srv_register_update(s);
1046
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001047 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001048 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1049 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001050 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001051
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001052 if (mode & SRV_ADMF_MAINT)
1053 mode = SRV_ADMF_IMAINT;
1054 else if (mode & SRV_ADMF_DRAIN)
1055 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001056
Emeric Brun9f0b4582017-10-23 14:39:51 +02001057 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001058 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001059 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001060 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001061 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001062}
1063
Willy Tarreau757478e2016-11-03 19:22:19 +01001064/* principle: propagate maint and drain to tracking servers. This is useful
1065 * upon startup so that inherited states are correct.
1066 */
1067static void srv_propagate_admin_state(struct server *srv)
1068{
1069 struct server *srv2;
1070
1071 if (!srv->trackers)
1072 return;
1073
1074 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001075 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001076 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001077 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001078
Emeric Brun52a91d32017-08-31 14:41:55 +02001079 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001080 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001081 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001082 }
1083}
1084
1085/* Compute and propagate the admin states for all servers in proxy <px>.
1086 * Only servers *not* tracking another one are considered, because other
1087 * ones will be handled when the server they track is visited.
1088 */
1089void srv_compute_all_admin_states(struct proxy *px)
1090{
1091 struct server *srv;
1092
1093 for (srv = px->srv; srv; srv = srv->next) {
1094 if (srv->track)
1095 continue;
1096 srv_propagate_admin_state(srv);
1097 }
1098}
1099
Willy Tarreaudff55432012-10-10 17:51:05 +02001100/* Note: must not be declared <const> as its list will be overwritten.
1101 * Please take care of keeping this list alphabetically sorted, doing so helps
1102 * all code contributors.
1103 * Optional keywords are also declared with a NULL ->parse() function so that
1104 * the config parser can report an appropriate error when a known keyword was
1105 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001106 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001107 */
1108static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille6e5e0d82017-03-20 16:30:18 +01001109 { "addr", srv_parse_addr, 1, 1 }, /* IP address to send health to or to probe from agent-check */
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001110 { "agent-check", srv_parse_agent_check, 0, 1 }, /* Enable an auxiliary agent check */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001111 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille65aa3562017-03-14 11:20:13 +01001112 { "check", srv_parse_check, 0, 1 }, /* enable health checks */
Frédéric Lécaille25df8902017-03-10 14:04:31 +01001113 { "check-send-proxy", srv_parse_check_send_proxy, 0, 1 }, /* enable PROXY protocol for health checks */
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +01001114 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001115 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1116 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001117 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Frédéric Lécaille22f41a22017-03-16 17:17:36 +01001118 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001119 { "no-agent-check", srv_parse_no_agent_check, 0, 1 }, /* Do not enable any auxiliary agent check */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001120 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille65aa3562017-03-14 11:20:13 +01001121 { "no-check", srv_parse_no_check, 0, 1 }, /* disable health checks */
Frédéric Lécaille25df8902017-03-10 14:04:31 +01001122 { "no-check-send-proxy", srv_parse_no_check_send_proxy, 0, 1 }, /* disable PROXY protol for health checks */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001123 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1124 { "no-send-proxy-v2", srv_parse_no_send_proxy_v2, 0, 1 }, /* Disable use of PROXY V2 protocol */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001125 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001126 { "observe", srv_parse_observe, 1, 1 }, /* Enables health adjusting based on observing communication with the server */
Frédéric Lécaille16186232017-03-14 16:42:49 +01001127 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001128 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1129 { "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 +02001130 { "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 +01001131 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001132 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Willy Tarreaudff55432012-10-10 17:51:05 +02001133 { NULL, NULL, 0 },
1134}};
1135
1136__attribute__((constructor))
1137static void __listener_init(void)
1138{
1139 srv_register_keywords(&srv_kws);
1140}
1141
Willy Tarreau004e0452013-11-21 11:22:01 +01001142/* Recomputes the server's eweight based on its state, uweight, the current time,
1143 * and the proxy's algorihtm. To be used after updating sv->uweight. The warmup
1144 * state is automatically disabled if the time is elapsed.
1145 */
1146void server_recalc_eweight(struct server *sv)
1147{
1148 struct proxy *px = sv->proxy;
1149 unsigned w;
1150
1151 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1152 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001153 if (sv->next_state == SRV_ST_STARTING)
1154 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001155 }
1156
1157 /* We must take care of not pushing the server to full throttle during slow starts.
1158 * It must also start immediately, at least at the minimal step when leaving maintenance.
1159 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001160 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001161 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1162 else
1163 w = px->lbprm.wdiv;
1164
Emeric Brun52a91d32017-08-31 14:41:55 +02001165 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001166
Christopher Faulet5d42e092017-10-16 12:00:40 +02001167 srv_register_update(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001168}
1169
Willy Tarreaubaaee002006-06-26 02:48:02 +02001170/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001171 * Parses weight_str and configures sv accordingly.
1172 * Returns NULL on success, error message string otherwise.
1173 */
1174const char *server_parse_weight_change_request(struct server *sv,
1175 const char *weight_str)
1176{
1177 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001178 long int w;
1179 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001180
1181 px = sv->proxy;
1182
1183 /* if the weight is terminated with '%', it is set relative to
1184 * the initial weight, otherwise it is absolute.
1185 */
1186 if (!*weight_str)
1187 return "Require <weight> or <weight%>.\n";
1188
Simon Hormanb796afa2013-02-12 10:45:53 +09001189 w = strtol(weight_str, &end, 10);
1190 if (end == weight_str)
1191 return "Empty weight string empty or preceded by garbage";
1192 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001193 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001194 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001195 /* Avoid integer overflow */
1196 if (w > 25600)
1197 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001198 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001199 if (w > 256)
1200 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001201 }
1202 else if (w < 0 || w > 256)
1203 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001204 else if (end[0] != '\0')
1205 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001206
1207 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1208 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1209
1210 sv->uweight = w;
Willy Tarreau004e0452013-11-21 11:22:01 +01001211 server_recalc_eweight(sv);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001212
1213 return NULL;
1214}
1215
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001216/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001217 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1218 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001219 * Returns:
1220 * - error string on error
1221 * - NULL on success
1222 */
1223const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001224 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001225{
1226 unsigned char ip[INET6_ADDRSTRLEN];
1227
1228 if (inet_pton(AF_INET6, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001229 update_server_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001230 return NULL;
1231 }
1232 if (inet_pton(AF_INET, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001233 update_server_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001234 return NULL;
1235 }
1236
1237 return "Could not understand IP address format.\n";
1238}
1239
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001240const char *server_parse_maxconn_change_request(struct server *sv,
1241 const char *maxconn_str)
1242{
1243 long int v;
1244 char *end;
1245
1246 if (!*maxconn_str)
1247 return "Require <maxconn>.\n";
1248
1249 v = strtol(maxconn_str, &end, 10);
1250 if (end == maxconn_str)
1251 return "maxconn string empty or preceded by garbage";
1252 else if (end[0] != '\0')
1253 return "Trailing garbage in maxconn string";
1254
1255 if (sv->maxconn == sv->minconn) { // static maxconn
1256 sv->maxconn = sv->minconn = v;
1257 } else { // dynamic maxconn
1258 sv->maxconn = v;
1259 }
1260
1261 if (may_dequeue_tasks(sv, sv->proxy))
1262 process_srv_queue(sv);
1263
1264 return NULL;
1265}
1266
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001267#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001268static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1269 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001270{
1271 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001272 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001273 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001274 NULL,
1275 };
1276
1277 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001278 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001279
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001280 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args);
1281}
1282
1283static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1284{
1285 struct sample_expr *expr;
1286
1287 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 +01001288 if (!expr) {
1289 memprintf(err, "error detected while parsing sni expression : %s", *err);
1290 return ERR_ALERT | ERR_FATAL;
1291 }
1292
1293 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1294 memprintf(err, "error detected while parsing sni expression : "
1295 " fetch method '%s' extracts information from '%s', "
1296 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001297 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001298 return ERR_ALERT | ERR_FATAL;
1299 }
1300
1301 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1302 release_sample_expr(newsrv->ssl_ctx.sni);
1303 newsrv->ssl_ctx.sni = expr;
1304
1305 return 0;
1306}
1307#endif
1308
1309static void display_parser_err(const char *file, int linenum, char **args, int cur_arg, char **err)
1310{
1311 if (err && *err) {
1312 indent_msg(err, 2);
Christopher Faulet767a84b2017-11-24 16:50:31 +01001313 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], *err);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001314 }
1315 else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001316 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while processing '%s'.\n",
1317 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001318}
1319
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001320static void srv_conn_src_sport_range_cpy(struct server *srv,
1321 struct server *src)
1322{
1323 int range_sz;
1324
1325 range_sz = src->conn_src.sport_range->size;
1326 if (range_sz > 0) {
1327 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1328 if (srv->conn_src.sport_range != NULL) {
1329 int i;
1330
1331 for (i = 0; i < range_sz; i++) {
1332 srv->conn_src.sport_range->ports[i] =
1333 src->conn_src.sport_range->ports[i];
1334 }
1335 }
1336 }
1337}
1338
1339/*
1340 * Copy <src> server connection source settings to <srv> server everything needed.
1341 */
1342static void srv_conn_src_cpy(struct server *srv, struct server *src)
1343{
1344 srv->conn_src.opts = src->conn_src.opts;
1345 srv->conn_src.source_addr = src->conn_src.source_addr;
1346
1347 /* Source port range copy. */
1348 if (src->conn_src.sport_range != NULL)
1349 srv_conn_src_sport_range_cpy(srv, src);
1350
1351#ifdef CONFIG_HAP_TRANSPARENT
1352 if (src->conn_src.bind_hdr_name != NULL) {
1353 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1354 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1355 }
1356 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1357 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1358#endif
1359 if (src->conn_src.iface_name != NULL)
1360 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1361}
1362
1363/*
1364 * Copy <src> server SSL settings to <srv> server allocating
1365 * everything needed.
1366 */
1367#if defined(USE_OPENSSL)
1368static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1369{
1370 if (src->ssl_ctx.ca_file != NULL)
1371 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1372 if (src->ssl_ctx.crl_file != NULL)
1373 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
1374 if (src->ssl_ctx.client_crt != NULL)
1375 srv->ssl_ctx.client_crt = strdup(src->ssl_ctx.client_crt);
1376
1377 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1378
1379 if (src->ssl_ctx.verify_host != NULL)
1380 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1381 if (src->ssl_ctx.ciphers != NULL)
1382 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
1383 if (src->sni_expr != NULL)
1384 srv->sni_expr = strdup(src->sni_expr);
1385}
1386#endif
1387
1388/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001389 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001390 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001391 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001392 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001393static int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001394{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001395 char *hostname_dn;
1396 int hostname_len, hostname_dn_len;
1397
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001398 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001399 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001400
Christopher Faulet67957bd2017-09-27 11:00:59 +02001401 hostname_len = strlen(hostname);
1402 hostname_dn = trash.str;
1403 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
1404 hostname_dn, trash.size);
1405 if (hostname_dn_len == -1)
1406 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001407
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001408
Christopher Faulet67957bd2017-09-27 11:00:59 +02001409 free(srv->hostname);
1410 free(srv->hostname_dn);
1411 srv->hostname = strdup(hostname);
1412 srv->hostname_dn = strdup(hostname_dn);
1413 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001414 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001415 goto err;
1416
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001417 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001418
1419 err:
Christopher Faulet67957bd2017-09-27 11:00:59 +02001420 free(srv->hostname); srv->hostname = NULL;
1421 free(srv->hostname_dn); srv->hostname_dn = NULL;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001422 return -1;
1423}
1424
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001425/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001426 * Copy <src> server settings to <srv> server allocating
1427 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001428 * This function is not supposed to be called at any time, but only
1429 * during server settings parsing or during server allocations from
1430 * a server template, and just after having calloc()'ed a new server.
1431 * So, <src> may only be a default server (when parsing server settings)
1432 * or a server template (during server allocations from a server template).
1433 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1434 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001435 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001436static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001437{
1438 /* Connection source settings copy */
1439 srv_conn_src_cpy(srv, src);
1440
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001441 if (srv_tmpl) {
1442 srv->addr = src->addr;
1443 srv->svc_port = src->svc_port;
1444 }
1445
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001446 srv->pp_opts = src->pp_opts;
1447 if (src->rdr_pfx != NULL) {
1448 srv->rdr_pfx = strdup(src->rdr_pfx);
1449 srv->rdr_len = src->rdr_len;
1450 }
1451 if (src->cookie != NULL) {
1452 srv->cookie = strdup(src->cookie);
1453 srv->cklen = src->cklen;
1454 }
1455 srv->use_ssl = src->use_ssl;
1456 srv->check.addr = srv->agent.addr = src->check.addr;
1457 srv->check.use_ssl = src->check.use_ssl;
1458 srv->check.port = src->check.port;
1459 /* Note: 'flags' field has potentially been already initialized. */
1460 srv->flags |= src->flags;
1461 srv->do_check = src->do_check;
1462 srv->do_agent = src->do_agent;
1463 if (srv->check.port)
1464 srv->flags |= SRV_F_CHECKPORT;
1465 srv->check.inter = src->check.inter;
1466 srv->check.fastinter = src->check.fastinter;
1467 srv->check.downinter = src->check.downinter;
1468 srv->agent.use_ssl = src->agent.use_ssl;
1469 srv->agent.port = src->agent.port;
1470 if (src->agent.send_string != NULL)
1471 srv->agent.send_string = strdup(src->agent.send_string);
1472 srv->agent.send_string_len = src->agent.send_string_len;
1473 srv->agent.inter = src->agent.inter;
1474 srv->agent.fastinter = src->agent.fastinter;
1475 srv->agent.downinter = src->agent.downinter;
1476 srv->maxqueue = src->maxqueue;
1477 srv->minconn = src->minconn;
1478 srv->maxconn = src->maxconn;
1479 srv->slowstart = src->slowstart;
1480 srv->observe = src->observe;
1481 srv->onerror = src->onerror;
1482 srv->onmarkeddown = src->onmarkeddown;
1483 srv->onmarkedup = src->onmarkedup;
1484 if (src->trackit != NULL)
1485 srv->trackit = strdup(src->trackit);
1486 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1487 srv->uweight = srv->iweight = src->iweight;
1488
1489 srv->check.send_proxy = src->check.send_proxy;
1490 /* health: up, but will fall down at first failure */
1491 srv->check.rise = srv->check.health = src->check.rise;
1492 srv->check.fall = src->check.fall;
1493
1494 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001495 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1496 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1497 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001498 srv->check.state |= CHK_ST_PAUSED;
1499 srv->check.health = 0;
1500 }
1501
1502 /* health: up but will fall down at first failure */
1503 srv->agent.rise = srv->agent.health = src->agent.rise;
1504 srv->agent.fall = src->agent.fall;
1505
1506 if (src->resolvers_id != NULL)
1507 srv->resolvers_id = strdup(src->resolvers_id);
1508 srv->dns_opts.family_prio = src->dns_opts.family_prio;
1509 if (srv->dns_opts.family_prio == AF_UNSPEC)
1510 srv->dns_opts.family_prio = AF_INET6;
1511 memcpy(srv->dns_opts.pref_net,
1512 src->dns_opts.pref_net,
1513 sizeof srv->dns_opts.pref_net);
1514 srv->dns_opts.pref_net_nb = src->dns_opts.pref_net_nb;
1515
1516 srv->init_addr_methods = src->init_addr_methods;
1517 srv->init_addr = src->init_addr;
1518#if defined(USE_OPENSSL)
1519 srv_ssl_settings_cpy(srv, src);
1520#endif
1521#ifdef TCP_USER_TIMEOUT
1522 srv->tcp_ut = src->tcp_ut;
1523#endif
Olivier Houchard8da5f982017-08-04 18:35:36 +02001524 if (srv_tmpl)
1525 srv->srvrq = src->srvrq;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001526}
1527
1528static struct server *new_server(struct proxy *proxy)
1529{
1530 struct server *srv;
Christopher Faulet40a007c2017-07-03 15:41:01 +02001531 int i;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001532
1533 srv = calloc(1, sizeof *srv);
1534 if (!srv)
1535 return NULL;
1536
1537 srv->obj_type = OBJ_TYPE_SERVER;
1538 srv->proxy = proxy;
1539 LIST_INIT(&srv->actconns);
1540 LIST_INIT(&srv->pendconns);
Christopher Faulet40a007c2017-07-03 15:41:01 +02001541
1542 if ((srv->priv_conns = calloc(global.nbthread, sizeof(*srv->priv_conns))) == NULL)
1543 goto free_srv;
1544 if ((srv->idle_conns = calloc(global.nbthread, sizeof(*srv->idle_conns))) == NULL)
1545 goto free_priv_conns;
1546 if ((srv->safe_conns = calloc(global.nbthread, sizeof(*srv->safe_conns))) == NULL)
1547 goto free_idle_conns;
1548
1549 for (i = 0; i < global.nbthread; i++) {
1550 LIST_INIT(&srv->priv_conns[i]);
1551 LIST_INIT(&srv->idle_conns[i]);
1552 LIST_INIT(&srv->safe_conns[i]);
1553 }
1554
Emeric Brun64cc49c2017-10-03 14:46:45 +02001555 LIST_INIT(&srv->update_status);
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001556
Emeric Brun52a91d32017-08-31 14:41:55 +02001557 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001558 srv->last_change = now.tv_sec;
1559
1560 srv->check.status = HCHK_STATUS_INI;
1561 srv->check.server = srv;
1562 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
1563
1564 srv->agent.status = HCHK_STATUS_INI;
1565 srv->agent.server = srv;
1566 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
1567
1568 return srv;
Christopher Faulet40a007c2017-07-03 15:41:01 +02001569
1570 free_idle_conns:
1571 free(srv->idle_conns);
1572 free_priv_conns:
1573 free(srv->priv_conns);
1574 free_srv:
1575 free(srv);
1576 return NULL;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001577}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001578
1579/*
1580 * Validate <srv> server health-check settings.
1581 * Returns 0 if everything is OK, -1 if not.
1582 */
1583static int server_healthcheck_validate(const char *file, int linenum, struct server *srv)
1584{
1585 struct tcpcheck_rule *r = NULL;
1586 struct list *l;
1587
1588 /*
1589 * We need at least a service port, a check port or the first tcp-check rule must
1590 * be a 'connect' one when checking an IPv4/IPv6 server.
1591 */
1592 if ((srv_check_healthcheck_port(&srv->check) != 0) ||
1593 (!is_inet_addr(&srv->check.addr) && (is_addr(&srv->check.addr) || !is_inet_addr(&srv->addr))))
1594 return 0;
1595
1596 r = (struct tcpcheck_rule *)srv->proxy->tcpcheck_rules.n;
1597 if (!r) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001598 ha_alert("parsing [%s:%d] : server %s has neither service port nor check port. "
1599 "Check has been disabled.\n",
1600 file, linenum, srv->id);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001601 return -1;
1602 }
1603
1604 /* search the first action (connect / send / expect) in the list */
1605 l = &srv->proxy->tcpcheck_rules;
1606 list_for_each_entry(r, l, list) {
1607 if (r->action != TCPCHK_ACT_COMMENT)
1608 break;
1609 }
1610
1611 if ((r->action != TCPCHK_ACT_CONNECT) || !r->port) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001612 ha_alert("parsing [%s:%d] : server %s has neither service port nor check port "
1613 "nor tcp_check rule 'connect' with port information. Check has been disabled.\n",
1614 file, linenum, srv->id);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001615 return -1;
1616 }
1617
1618 /* scan the tcp-check ruleset to ensure a port has been configured */
1619 l = &srv->proxy->tcpcheck_rules;
1620 list_for_each_entry(r, l, list) {
1621 if ((r->action == TCPCHK_ACT_CONNECT) && (!r->port)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001622 ha_alert("parsing [%s:%d] : server %s has neither service port nor check port, "
1623 "and a tcp_check rule 'connect' with no port information. Check has been disabled.\n",
1624 file, linenum, srv->id);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001625 return -1;
1626 }
1627 }
1628
1629 return 0;
1630}
1631
1632/*
1633 * Initialize <srv> health-check structure.
1634 * Returns the error string in case of memory allocation failure, NULL if not.
1635 */
1636static const char *do_health_check_init(struct server *srv, int check_type, int state)
1637{
1638 const char *ret;
1639
1640 if (!srv->do_check)
1641 return NULL;
1642
1643 ret = init_check(&srv->check, check_type);
1644 if (ret)
1645 return ret;
1646
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001647 srv->check.state |= state;
1648 global.maxsock++;
1649
1650 return NULL;
1651}
1652
1653static int server_health_check_init(const char *file, int linenum,
1654 struct server *srv, struct proxy *curproxy)
1655{
1656 const char *ret;
1657
1658 if (!srv->do_check)
1659 return 0;
1660
1661 if (srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001662 ha_alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1663 file, linenum);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001664 return ERR_ALERT | ERR_FATAL;
1665 }
1666
1667 if (server_healthcheck_validate(file, linenum, srv) < 0)
1668 return ERR_ALERT | ERR_ABORT;
1669
1670 /* note: check type will be set during the config review phase */
1671 ret = do_health_check_init(srv, 0, CHK_ST_CONFIGURED | CHK_ST_ENABLED);
1672 if (ret) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001673 ha_alert("parsing [%s:%d] : %s.\n", file, linenum, ret);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001674 return ERR_ALERT | ERR_ABORT;
1675 }
1676
1677 return 0;
1678}
1679
1680/*
1681 * Initialize <srv> agent check structure.
1682 * Returns the error string in case of memory allocation failure, NULL if not.
1683 */
1684static const char *do_server_agent_check_init(struct server *srv, int state)
1685{
1686 const char *ret;
1687
1688 if (!srv->do_agent)
1689 return NULL;
1690
1691 ret = init_check(&srv->agent, PR_O2_LB_AGENT_CHK);
1692 if (ret)
1693 return ret;
1694
1695 if (!srv->agent.inter)
1696 srv->agent.inter = srv->check.inter;
1697
1698 srv->agent.state |= state;
1699 global.maxsock++;
1700
1701 return NULL;
1702}
1703
1704static int server_agent_check_init(const char *file, int linenum,
1705 struct server *srv, struct proxy *curproxy)
1706{
1707 const char *ret;
1708
1709 if (!srv->do_agent)
1710 return 0;
1711
1712 if (!srv->agent.port) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001713 ha_alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001714 file, linenum, srv->id);
1715 return ERR_ALERT | ERR_FATAL;
1716 }
1717
1718 ret = do_server_agent_check_init(srv, CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT);
1719 if (ret) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001720 ha_alert("parsing [%s:%d] : %s.\n", file, linenum, ret);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001721 return ERR_ALERT | ERR_ABORT;
1722 }
1723
1724 return 0;
1725}
1726
1727#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1728static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
1729 struct server *srv, struct proxy *proxy)
1730{
1731 int ret;
1732 char *err = NULL;
1733
1734 if (!srv->sni_expr)
1735 return 0;
1736
1737 ret = server_parse_sni_expr(srv, proxy, &err);
1738 if (!ret)
1739 return 0;
1740
1741 display_parser_err(file, linenum, args, cur_arg, &err);
1742 free(err);
1743
1744 return ret;
1745}
1746#endif
1747
1748/*
1749 * Server initializations finalization.
1750 * Initialize health check, agent check and SNI expression if enabled.
1751 * Must not be called for a default server instance.
1752 */
1753static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
1754 struct server *srv, struct proxy *px)
1755{
1756 int ret;
1757
1758 if ((ret = server_health_check_init(file, linenum, srv, px)) != 0 ||
1759 (ret = server_agent_check_init(file, linenum, srv, px)) != 0) {
1760 return ret;
1761 }
1762
1763#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1764 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
1765 return ret;
1766#endif
1767
1768 if (srv->flags & SRV_F_BACKUP)
1769 px->srv_bck++;
1770 else
1771 px->srv_act++;
1772 srv_lb_commit_status(srv);
1773
1774 return 0;
1775}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001776
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001777/*
1778 * Parse as much as possible such a range string argument: low[-high]
1779 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
1780 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
1781 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
1782 * Returns 0 if succeeded, -1 if not.
1783 */
1784static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
1785{
1786 char *nb_high_arg;
1787
1788 *nb_high = 0;
1789 chunk_printf(&trash, "%s", arg);
1790 *nb_low = atoi(trash.str);
1791
1792 if ((nb_high_arg = strchr(trash.str, '-'))) {
1793 *nb_high_arg++ = '\0';
1794 *nb_high = atoi(nb_high_arg);
1795 }
1796 else {
1797 *nb_high += *nb_low;
1798 *nb_low = 1;
1799 }
1800
1801 if (*nb_low < 0 || *nb_high < *nb_low)
1802 return -1;
1803
1804 return 0;
1805}
1806
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001807static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
1808{
1809 chunk_printf(&trash, "%s%d", prefix, nb);
1810 free(srv->id);
1811 srv->id = strdup(trash.str);
1812}
1813
1814/*
1815 * Initialize as much as possible servers from <srv> server template.
1816 * Note that a server template is a special server with
1817 * a few different parameters than a server which has
1818 * been parsed mostly the same way as a server.
1819 * Returns the number of servers succesfully allocated,
1820 * 'srv' template included.
1821 */
1822static int server_template_init(struct server *srv, struct proxy *px)
1823{
1824 int i;
1825 struct server *newsrv;
1826
1827 for (i = srv->tmpl_info.nb_low + 1; i <= srv->tmpl_info.nb_high; i++) {
1828 int check_init_state;
1829 int agent_init_state;
1830
1831 newsrv = new_server(px);
1832 if (!newsrv)
1833 goto err;
1834
1835 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001836 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001837#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1838 if (newsrv->sni_expr) {
1839 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
1840 if (!newsrv->ssl_ctx.sni)
1841 goto err;
1842 }
1843#endif
1844 /* Set this new server ID. */
1845 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
1846
1847 /* Initial checks states. */
1848 check_init_state = CHK_ST_CONFIGURED | CHK_ST_ENABLED;
1849 agent_init_state = CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT;
1850
1851 if (do_health_check_init(newsrv, px->options2 & PR_O2_CHK_ANY, check_init_state) ||
1852 do_server_agent_check_init(newsrv, agent_init_state))
1853 goto err;
1854
1855 /* Linked backwards first. This will be restablished after parsing. */
1856 newsrv->next = px->srv;
1857 px->srv = newsrv;
1858 }
1859 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1860
1861 return i - srv->tmpl_info.nb_low;
1862
1863 err:
1864 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1865 if (newsrv) {
1866#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1867 release_sample_expr(newsrv->ssl_ctx.sni);
1868#endif
1869 free_check(&newsrv->agent);
1870 free_check(&newsrv->check);
1871 }
1872 free(newsrv);
1873 return i - srv->tmpl_info.nb_low;
1874}
1875
Willy Tarreau272adea2014-03-31 10:39:59 +02001876int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy, struct proxy *defproxy)
1877{
1878 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001879 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001880 char *errmsg = NULL;
1881 int err_code = 0;
1882 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02001883 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001884
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001885 if (!strcmp(args[0], "server") ||
1886 !strcmp(args[0], "default-server") ||
1887 !strcmp(args[0], "server-template")) {
Willy Tarreau272adea2014-03-31 10:39:59 +02001888 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001889 int defsrv = (*args[0] == 'd');
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001890 int srv = !defsrv && !strcmp(args[0], "server");
1891 int srv_tmpl = !defsrv && !srv;
1892 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02001893
1894 if (!defsrv && curproxy == defproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001895 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001896 err_code |= ERR_ALERT | ERR_FATAL;
1897 goto out;
1898 }
1899 else if (warnifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL))
1900 err_code |= ERR_ALERT | ERR_FATAL;
1901
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001902 /* There is no mandatory first arguments for default server. */
1903 if (srv) {
1904 if (!*args[2]) {
1905 /* 'server' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001906 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001907 file, linenum, args[0]);
1908 err_code |= ERR_ALERT | ERR_FATAL;
1909 goto out;
1910 }
1911
1912 err = invalid_char(args[1]);
1913 }
1914 else if (srv_tmpl) {
1915 if (!*args[3]) {
1916 /* 'server-template' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001917 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 +02001918 file, linenum, args[0]);
1919 err_code |= ERR_ALERT | ERR_FATAL;
1920 goto out;
1921 }
1922
1923 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001924 }
1925
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001926 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001927 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 +02001928 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001929 err_code |= ERR_ALERT | ERR_FATAL;
1930 goto out;
1931 }
1932
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001933 cur_arg = 2;
1934 if (srv_tmpl) {
1935 /* Parse server-template <nb | range> arg. */
1936 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001937 ha_alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001938 file, linenum, args[0], args[cur_arg]);
1939 err_code |= ERR_ALERT | ERR_FATAL;
1940 goto out;
1941 }
1942 cur_arg++;
1943 }
1944
Willy Tarreau272adea2014-03-31 10:39:59 +02001945 if (!defsrv) {
1946 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01001947 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02001948 struct protocol *proto;
1949
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001950 newsrv = new_server(curproxy);
1951 if (!newsrv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001952 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Willy Tarreau272adea2014-03-31 10:39:59 +02001953 err_code |= ERR_ALERT | ERR_ABORT;
1954 goto out;
1955 }
1956
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001957 if (srv_tmpl) {
1958 newsrv->tmpl_info.nb_low = tmpl_range_low;
1959 newsrv->tmpl_info.nb_high = tmpl_range_high;
1960 }
1961
Willy Tarreau272adea2014-03-31 10:39:59 +02001962 /* the servers are linked backwards first */
1963 newsrv->next = curproxy->srv;
1964 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02001965 newsrv->conf.file = strdup(file);
1966 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001967 /* Note: for a server template, its id is its prefix.
1968 * This is a temporary id which will be used for server allocations to come
1969 * after parsing.
1970 */
1971 if (srv)
1972 newsrv->id = strdup(args[1]);
1973 else
1974 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001975
1976 /* several ways to check the port component :
1977 * - IP => port=+0, relative (IPv4 only)
1978 * - IP: => port=+0, relative
1979 * - IP:N => port=N, absolute
1980 * - IP:+N => port=+N, relative
1981 * - IP:-N => port=-N, relative
1982 */
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001983 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, &errmsg, NULL, &fqdn, 0);
Willy Tarreau272adea2014-03-31 10:39:59 +02001984 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001985 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau272adea2014-03-31 10:39:59 +02001986 err_code |= ERR_ALERT | ERR_FATAL;
1987 goto out;
1988 }
1989
1990 proto = protocol_by_family(sk->ss_family);
Willy Tarreau9698f4b2017-01-06 18:42:57 +01001991 if (!fqdn && (!proto || !proto->connect)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001992 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02001993 file, linenum, args[0], args[1]);
1994 err_code |= ERR_ALERT | ERR_FATAL;
1995 goto out;
1996 }
1997
1998 if (!port1 || !port2) {
1999 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002000 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002001 }
2002 else if (port1 != port2) {
2003 /* port range */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002004 ha_alert("parsing [%s:%d] : '%s %s' : port ranges are not allowed in '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002005 file, linenum, args[0], args[1], args[2]);
2006 err_code |= ERR_ALERT | ERR_FATAL;
2007 goto out;
2008 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002009
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002010 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002011 if (fqdn) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002012 if (fqdn[0] == '_') { /* SRV record */
Olivier Houchard8da5f982017-08-04 18:35:36 +02002013 /* Check if a SRV request already exists, and if not, create it */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002014 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
2015 newsrv->srvrq = new_dns_srvrq(newsrv, fqdn);
2016 if (newsrv->srvrq == NULL) {
Olivier Houchard8da5f982017-08-04 18:35:36 +02002017 err_code |= ERR_ALERT | ERR_FATAL;
2018 goto out;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002019 }
2020 }
2021 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002022 ha_alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
Christopher Faulet67957bd2017-09-27 11:00:59 +02002023 file, linenum, newsrv->id);
2024 err_code |= ERR_ALERT | ERR_FATAL;
2025 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002026 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002027 }
2028
Willy Tarreau272adea2014-03-31 10:39:59 +02002029 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002030 newsrv->svc_port = port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002031
Olivier Houchard8da5f982017-08-04 18:35:36 +02002032 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002033 ha_alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002034 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002035 err_code |= ERR_ALERT | ERR_FATAL;
2036 goto out;
2037 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002038
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002039 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002040 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002041 HA_SPIN_INIT(&newsrv->lock);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002042 cur_arg++;
Willy Tarreau272adea2014-03-31 10:39:59 +02002043 } else {
2044 newsrv = &curproxy->defsrv;
2045 cur_arg = 1;
Thierry Fournierada34842016-02-17 21:25:09 +01002046 newsrv->dns_opts.family_prio = AF_INET6;
Willy Tarreau272adea2014-03-31 10:39:59 +02002047 }
2048
2049 while (*args[cur_arg]) {
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01002050 if (!strcmp(args[cur_arg], "agent-inter")) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002051 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2052 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002053 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'agent-inter' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002054 file, linenum, *err, newsrv->id);
2055 err_code |= ERR_ALERT | ERR_FATAL;
2056 goto out;
2057 }
2058 if (val <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002059 ha_alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002060 file, linenum, val, args[cur_arg], newsrv->id);
2061 err_code |= ERR_ALERT | ERR_FATAL;
2062 goto out;
2063 }
2064 newsrv->agent.inter = val;
2065 cur_arg += 2;
2066 }
Misiekea849332017-01-09 09:39:51 +01002067 else if (!strcmp(args[cur_arg], "agent-addr")) {
2068 if(str2ip(args[cur_arg + 1], &newsrv->agent.addr) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002069 ha_alert("parsing agent-addr failed. Check if %s is correct address.\n", args[cur_arg + 1]);
Misiekea849332017-01-09 09:39:51 +01002070 goto out;
2071 }
2072
2073 cur_arg += 2;
2074 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002075 else if (!strcmp(args[cur_arg], "agent-port")) {
2076 global.maxsock++;
2077 newsrv->agent.port = atol(args[cur_arg + 1]);
2078 cur_arg += 2;
2079 }
James Brown55f9ff12015-10-21 18:19:05 -07002080 else if (!strcmp(args[cur_arg], "agent-send")) {
2081 global.maxsock++;
2082 free(newsrv->agent.send_string);
2083 newsrv->agent.send_string_len = strlen(args[cur_arg + 1]);
2084 newsrv->agent.send_string = calloc(1, newsrv->agent.send_string_len + 1);
2085 memcpy(newsrv->agent.send_string, args[cur_arg + 1], newsrv->agent.send_string_len);
2086 cur_arg += 2;
2087 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002088 else if (!strcmp(args[cur_arg], "init-addr")) {
2089 char *p, *end;
2090 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002091 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002092
2093 newsrv->init_addr_methods = 0;
2094 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2095
2096 for (p = args[cur_arg + 1]; *p; p = end) {
2097 /* cut on next comma */
2098 for (end = p; *end && *end != ','; end++);
2099 if (*end)
2100 *(end++) = 0;
2101
Willy Tarreau4310d362016-11-02 15:05:56 +01002102 memset(&sa, 0, sizeof(sa));
Baptiste Assmann25938272016-09-21 20:26:16 +02002103 if (!strcmp(p, "libc")) {
2104 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2105 }
2106 else if (!strcmp(p, "last")) {
2107 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2108 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01002109 else if (!strcmp(p, "none")) {
2110 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2111 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002112 else if (str2ip2(p, &sa, 0)) {
2113 if (is_addr(&newsrv->init_addr)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002114 ha_alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
Willy Tarreau4310d362016-11-02 15:05:56 +01002115 file, linenum, args[cur_arg], p);
2116 err_code |= ERR_ALERT | ERR_FATAL;
2117 goto out;
2118 }
2119 newsrv->init_addr = sa;
2120 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2121 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002122 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002123 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 +02002124 file, linenum, args[cur_arg], p);
2125 err_code |= ERR_ALERT | ERR_FATAL;
2126 goto out;
2127 }
2128 if (!done) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002129 ha_alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002130 file, linenum, args[cur_arg], p);
2131 err_code |= ERR_ALERT | ERR_FATAL;
2132 goto out;
2133 }
2134 }
2135 cur_arg += 2;
2136 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002137 else if (!strcmp(args[cur_arg], "resolvers")) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002138 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002139 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2140 cur_arg += 2;
2141 }
2142 else if (!strcmp(args[cur_arg], "resolve-prefer")) {
2143 if (!strcmp(args[cur_arg + 1], "ipv4"))
Thierry Fournierada34842016-02-17 21:25:09 +01002144 newsrv->dns_opts.family_prio = AF_INET;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002145 else if (!strcmp(args[cur_arg + 1], "ipv6"))
Thierry Fournierada34842016-02-17 21:25:09 +01002146 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002147 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002148 ha_alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002149 file, linenum, args[cur_arg]);
2150 err_code |= ERR_ALERT | ERR_FATAL;
2151 goto out;
2152 }
2153 cur_arg += 2;
2154 }
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002155 else if (!strcmp(args[cur_arg], "resolve-net")) {
2156 char *p, *e;
2157 unsigned char mask;
2158 struct dns_options *opt;
2159
2160 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002161 ha_alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002162 file, linenum, args[cur_arg]);
2163 err_code |= ERR_ALERT | ERR_FATAL;
2164 goto out;
2165 }
2166
2167 opt = &newsrv->dns_opts;
2168
2169 /* Split arguments by comma, and convert it from ipv4 or ipv6
2170 * string network in in_addr or in6_addr.
2171 */
2172 p = args[cur_arg + 1];
2173 e = p;
2174 while (*p != '\0') {
2175 /* If no room avalaible, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002176 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002177 ha_alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002178 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2179 err_code |= ERR_ALERT | ERR_FATAL;
2180 goto out;
2181 }
2182 /* look for end or comma. */
2183 while (*e != ',' && *e != '\0')
2184 e++;
2185 if (*e == ',') {
2186 *e = '\0';
2187 e++;
2188 }
2189 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2190 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2191 /* Try to convert input string from ipv4 or ipv6 network. */
2192 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2193 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2194 &mask)) {
2195 /* Try to convert input string from ipv6 network. */
2196 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2197 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2198 } else {
2199 /* All network conversions fail, retrun error. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002200 ha_alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002201 file, linenum, args[cur_arg], p);
2202 err_code |= ERR_ALERT | ERR_FATAL;
2203 goto out;
2204 }
2205 opt->pref_net_nb++;
2206 p = e;
2207 }
2208
2209 cur_arg += 2;
2210 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002211 else if (!strcmp(args[cur_arg], "rise")) {
2212 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002213 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002214 file, linenum, args[cur_arg]);
2215 err_code |= ERR_ALERT | ERR_FATAL;
2216 goto out;
2217 }
2218
2219 newsrv->check.rise = atol(args[cur_arg + 1]);
2220 if (newsrv->check.rise <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002221 ha_alert("parsing [%s:%d]: '%s' has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002222 file, linenum, args[cur_arg]);
2223 err_code |= ERR_ALERT | ERR_FATAL;
2224 goto out;
2225 }
2226
2227 if (newsrv->check.health)
2228 newsrv->check.health = newsrv->check.rise;
2229 cur_arg += 2;
2230 }
2231 else if (!strcmp(args[cur_arg], "fall")) {
2232 newsrv->check.fall = atol(args[cur_arg + 1]);
2233
2234 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002235 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002236 file, linenum, args[cur_arg]);
2237 err_code |= ERR_ALERT | ERR_FATAL;
2238 goto out;
2239 }
2240
2241 if (newsrv->check.fall <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002242 ha_alert("parsing [%s:%d]: '%s' has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002243 file, linenum, args[cur_arg]);
2244 err_code |= ERR_ALERT | ERR_FATAL;
2245 goto out;
2246 }
2247
2248 cur_arg += 2;
2249 }
2250 else if (!strcmp(args[cur_arg], "inter")) {
2251 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2252 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002253 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'inter' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002254 file, linenum, *err, newsrv->id);
2255 err_code |= ERR_ALERT | ERR_FATAL;
2256 goto out;
2257 }
2258 if (val <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002259 ha_alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002260 file, linenum, val, args[cur_arg], newsrv->id);
2261 err_code |= ERR_ALERT | ERR_FATAL;
2262 goto out;
2263 }
2264 newsrv->check.inter = val;
2265 cur_arg += 2;
2266 }
2267 else if (!strcmp(args[cur_arg], "fastinter")) {
2268 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2269 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002270 ha_alert("parsing [%s:%d]: unexpected character '%c' in 'fastinter' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002271 file, linenum, *err, newsrv->id);
2272 err_code |= ERR_ALERT | ERR_FATAL;
2273 goto out;
2274 }
2275 if (val <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002276 ha_alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002277 file, linenum, val, args[cur_arg], newsrv->id);
2278 err_code |= ERR_ALERT | ERR_FATAL;
2279 goto out;
2280 }
2281 newsrv->check.fastinter = val;
2282 cur_arg += 2;
2283 }
2284 else if (!strcmp(args[cur_arg], "downinter")) {
2285 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2286 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002287 ha_alert("parsing [%s:%d]: unexpected character '%c' in 'downinter' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002288 file, linenum, *err, newsrv->id);
2289 err_code |= ERR_ALERT | ERR_FATAL;
2290 goto out;
2291 }
2292 if (val <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002293 ha_alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002294 file, linenum, val, args[cur_arg], newsrv->id);
2295 err_code |= ERR_ALERT | ERR_FATAL;
2296 goto out;
2297 }
2298 newsrv->check.downinter = val;
2299 cur_arg += 2;
2300 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002301 else if (!strcmp(args[cur_arg], "port")) {
2302 newsrv->check.port = atol(args[cur_arg + 1]);
Baptiste Assmann6b453f12016-08-11 23:12:18 +02002303 newsrv->flags |= SRV_F_CHECKPORT;
Willy Tarreau272adea2014-03-31 10:39:59 +02002304 cur_arg += 2;
2305 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002306 else if (!strcmp(args[cur_arg], "weight")) {
2307 int w;
2308 w = atol(args[cur_arg + 1]);
2309 if (w < 0 || w > SRV_UWGHT_MAX) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002310 ha_alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002311 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2312 err_code |= ERR_ALERT | ERR_FATAL;
2313 goto out;
2314 }
2315 newsrv->uweight = newsrv->iweight = w;
2316 cur_arg += 2;
2317 }
2318 else if (!strcmp(args[cur_arg], "minconn")) {
2319 newsrv->minconn = atol(args[cur_arg + 1]);
2320 cur_arg += 2;
2321 }
2322 else if (!strcmp(args[cur_arg], "maxconn")) {
2323 newsrv->maxconn = atol(args[cur_arg + 1]);
2324 cur_arg += 2;
2325 }
2326 else if (!strcmp(args[cur_arg], "maxqueue")) {
2327 newsrv->maxqueue = atol(args[cur_arg + 1]);
2328 cur_arg += 2;
2329 }
2330 else if (!strcmp(args[cur_arg], "slowstart")) {
2331 /* slowstart is stored in seconds */
2332 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2333 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002334 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002335 file, linenum, *err, newsrv->id);
2336 err_code |= ERR_ALERT | ERR_FATAL;
2337 goto out;
2338 }
2339 newsrv->slowstart = (val + 999) / 1000;
2340 cur_arg += 2;
2341 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002342 else if (!strcmp(args[cur_arg], "on-error")) {
2343 if (!strcmp(args[cur_arg + 1], "fastinter"))
2344 newsrv->onerror = HANA_ONERR_FASTINTER;
2345 else if (!strcmp(args[cur_arg + 1], "fail-check"))
2346 newsrv->onerror = HANA_ONERR_FAILCHK;
2347 else if (!strcmp(args[cur_arg + 1], "sudden-death"))
2348 newsrv->onerror = HANA_ONERR_SUDDTH;
2349 else if (!strcmp(args[cur_arg + 1], "mark-down"))
2350 newsrv->onerror = HANA_ONERR_MARKDWN;
2351 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002352 ha_alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
Willy Tarreau272adea2014-03-31 10:39:59 +02002353 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2354 file, linenum, args[cur_arg], args[cur_arg + 1]);
2355 err_code |= ERR_ALERT | ERR_FATAL;
2356 goto out;
2357 }
2358
2359 cur_arg += 2;
2360 }
2361 else if (!strcmp(args[cur_arg], "on-marked-down")) {
2362 if (!strcmp(args[cur_arg + 1], "shutdown-sessions"))
2363 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2364 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002365 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002366 file, linenum, args[cur_arg], args[cur_arg + 1]);
2367 err_code |= ERR_ALERT | ERR_FATAL;
2368 goto out;
2369 }
2370
2371 cur_arg += 2;
2372 }
2373 else if (!strcmp(args[cur_arg], "on-marked-up")) {
2374 if (!strcmp(args[cur_arg + 1], "shutdown-backup-sessions"))
2375 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2376 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002377 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002378 file, linenum, args[cur_arg], args[cur_arg + 1]);
2379 err_code |= ERR_ALERT | ERR_FATAL;
2380 goto out;
2381 }
2382
2383 cur_arg += 2;
2384 }
2385 else if (!strcmp(args[cur_arg], "error-limit")) {
2386 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002387 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002388 file, linenum, args[cur_arg]);
2389 err_code |= ERR_ALERT | ERR_FATAL;
2390 goto out;
2391 }
2392
2393 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2394
2395 if (newsrv->consecutive_errors_limit <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002396 ha_alert("parsing [%s:%d]: %s has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002397 file, linenum, args[cur_arg]);
2398 err_code |= ERR_ALERT | ERR_FATAL;
2399 goto out;
2400 }
2401 cur_arg += 2;
2402 }
Frédéric Lécaille8d083ed2017-04-14 15:19:56 +02002403 else if (!strcmp(args[cur_arg], "usesrc")) { /* address to use outside: needs "source" first */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002404 ha_alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002405 file, linenum, "usesrc", "source");
2406 err_code |= ERR_ALERT | ERR_FATAL;
2407 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002408 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002409 else {
2410 static int srv_dumped;
2411 struct srv_kw *kw;
2412 char *err;
2413
2414 kw = srv_find_kw(args[cur_arg]);
2415 if (kw) {
2416 char *err = NULL;
2417 int code;
2418
2419 if (!kw->parse) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002420 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 +02002421 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002422 if (kw->skip != -1)
2423 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002424 err_code |= ERR_ALERT | ERR_FATAL;
2425 goto out;
2426 }
2427
2428 if (defsrv && !kw->default_ok) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002429 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002430 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002431 if (kw->skip != -1)
2432 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002433 err_code |= ERR_ALERT;
2434 continue;
2435 }
2436
2437 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2438 err_code |= code;
2439
2440 if (code) {
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01002441 display_parser_err(file, linenum, args, cur_arg, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002442 if (code & ERR_FATAL) {
2443 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002444 if (kw->skip != -1)
2445 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002446 goto out;
2447 }
2448 }
2449 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002450 if (kw->skip != -1)
2451 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002452 continue;
2453 }
2454
2455 err = NULL;
2456 if (!srv_dumped) {
2457 srv_dump_kws(&err);
2458 indent_msg(&err, 4);
2459 srv_dumped = 1;
2460 }
2461
Christopher Faulet767a84b2017-11-24 16:50:31 +01002462 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002463 file, linenum, args[0], args[1], args[cur_arg],
2464 err ? " Registered keywords :" : "", err ? err : "");
2465 free(err);
2466
2467 err_code |= ERR_ALERT | ERR_FATAL;
2468 goto out;
2469 }
2470 }
2471
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002472 if (!defsrv)
2473 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2474 if (err_code & ERR_FATAL)
2475 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002476 if (srv_tmpl)
2477 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002478 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002479 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002480 return 0;
2481
2482 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002483 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002484 free(errmsg);
2485 return err_code;
2486}
2487
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002488/* Returns a pointer to the first server matching either id <id>.
2489 * NULL is returned if no match is found.
2490 * the lookup is performed in the backend <bk>
2491 */
2492struct server *server_find_by_id(struct proxy *bk, int id)
2493{
2494 struct eb32_node *eb32;
2495 struct server *curserver;
2496
2497 if (!bk || (id ==0))
2498 return NULL;
2499
2500 /* <bk> has no backend capabilities, so it can't have a server */
2501 if (!(bk->cap & PR_CAP_BE))
2502 return NULL;
2503
2504 curserver = NULL;
2505
2506 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2507 if (eb32)
2508 curserver = container_of(eb32, struct server, conf.id);
2509
2510 return curserver;
2511}
2512
2513/* Returns a pointer to the first server matching either name <name>, or id
2514 * if <name> starts with a '#'. NULL is returned if no match is found.
2515 * the lookup is performed in the backend <bk>
2516 */
2517struct server *server_find_by_name(struct proxy *bk, const char *name)
2518{
2519 struct server *curserver;
2520
2521 if (!bk || !name)
2522 return NULL;
2523
2524 /* <bk> has no backend capabilities, so it can't have a server */
2525 if (!(bk->cap & PR_CAP_BE))
2526 return NULL;
2527
2528 curserver = NULL;
2529 if (*name == '#') {
2530 curserver = server_find_by_id(bk, atoi(name + 1));
2531 if (curserver)
2532 return curserver;
2533 }
2534 else {
2535 curserver = bk->srv;
2536
2537 while (curserver && (strcmp(curserver->id, name) != 0))
2538 curserver = curserver->next;
2539
2540 if (curserver)
2541 return curserver;
2542 }
2543
2544 return NULL;
2545}
2546
2547struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2548{
2549 struct server *byname;
2550 struct server *byid;
2551
2552 if (!name && !id)
2553 return NULL;
2554
2555 if (diff)
2556 *diff = 0;
2557
2558 byname = byid = NULL;
2559
2560 if (name) {
2561 byname = server_find_by_name(bk, name);
2562 if (byname && (!id || byname->puid == id))
2563 return byname;
2564 }
2565
2566 /* remaining possibilities :
2567 * - name not set
2568 * - name set but not found
2569 * - name found but ID doesn't match
2570 */
2571 if (id) {
2572 byid = server_find_by_id(bk, id);
2573 if (byid) {
2574 if (byname) {
2575 /* use id only if forced by configuration */
2576 if (byid->flags & SRV_F_FORCED_ID) {
2577 if (diff)
2578 *diff |= 2;
2579 return byid;
2580 }
2581 else {
2582 if (diff)
2583 *diff |= 1;
2584 return byname;
2585 }
2586 }
2587
2588 /* remaining possibilities:
2589 * - name not set
2590 * - name set but not found
2591 */
2592 if (name && diff)
2593 *diff |= 2;
2594 return byid;
2595 }
2596
2597 /* id bot found */
2598 if (byname) {
2599 if (diff)
2600 *diff |= 1;
2601 return byname;
2602 }
2603 }
2604
2605 return NULL;
2606}
2607
Christopher Faulet5d42e092017-10-16 12:00:40 +02002608/* Registers changes to be applied asynchronously */
2609static void srv_register_update(struct server *srv)
2610{
2611 if (LIST_ISEMPTY(&srv->update_status)) {
2612 THREAD_WANT_SYNC();
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002613 HA_SPIN_LOCK(UPDATED_SERVERS_LOCK, &updated_servers_lock);
Christopher Faulet5d42e092017-10-16 12:00:40 +02002614 if (LIST_ISEMPTY(&srv->update_status))
2615 LIST_ADDQ(&updated_servers, &srv->update_status);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002616 HA_SPIN_UNLOCK(UPDATED_SERVERS_LOCK, &updated_servers_lock);
Christopher Faulet5d42e092017-10-16 12:00:40 +02002617 }
2618}
2619
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002620/* Update a server state using the parameters available in the params list */
2621static void srv_update_state(struct server *srv, int version, char **params)
2622{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002623 char *p;
Willy Tarreau31138fa2015-09-29 18:38:47 +02002624 struct chunk *msg;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002625
2626 /* fields since version 1
2627 * and common to all other upcoming versions
2628 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002629 enum srv_state srv_op_state;
2630 enum srv_admin srv_admin_state;
2631 unsigned srv_uweight, srv_iweight;
2632 unsigned long srv_last_time_change;
2633 short srv_check_status;
2634 enum chk_result srv_check_result;
2635 int srv_check_health;
2636 int srv_check_state, srv_agent_state;
2637 int bk_f_forced_id;
2638 int srv_f_forced_id;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002639 int fqdn_set_by_cli;
2640 const char *fqdn;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002641 const char *port_str;
2642 unsigned int port;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002643
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002644 fqdn = NULL;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002645 port = 0;
Willy Tarreau31138fa2015-09-29 18:38:47 +02002646 msg = get_trash_chunk();
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002647 switch (version) {
2648 case 1:
2649 /*
2650 * now we can proceed with server's state update:
2651 * srv_addr: params[0]
2652 * srv_op_state: params[1]
2653 * srv_admin_state: params[2]
2654 * srv_uweight: params[3]
2655 * srv_iweight: params[4]
2656 * srv_last_time_change: params[5]
2657 * srv_check_status: params[6]
2658 * srv_check_result: params[7]
2659 * srv_check_health: params[8]
2660 * srv_check_state: params[9]
2661 * srv_agent_state: params[10]
2662 * bk_f_forced_id: params[11]
2663 * srv_f_forced_id: params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002664 * srv_fqdn: params[13]
Frédéric Lécaille31694712017-08-01 08:47:19 +02002665 * srv_port: params[14]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002666 */
2667
2668 /* validating srv_op_state */
2669 p = NULL;
2670 errno = 0;
2671 srv_op_state = strtol(params[1], &p, 10);
2672 if ((p == params[1]) || errno == EINVAL || errno == ERANGE ||
2673 (srv_op_state != SRV_ST_STOPPED &&
2674 srv_op_state != SRV_ST_STARTING &&
2675 srv_op_state != SRV_ST_RUNNING &&
2676 srv_op_state != SRV_ST_STOPPING)) {
2677 chunk_appendf(msg, ", invalid srv_op_state value '%s'", params[1]);
2678 }
2679
2680 /* validating srv_admin_state */
2681 p = NULL;
2682 errno = 0;
2683 srv_admin_state = strtol(params[2], &p, 10);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002684 fqdn_set_by_cli = !!(srv_admin_state & SRV_ADMF_HMAINT);
Willy Tarreau757478e2016-11-03 19:22:19 +01002685
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002686 /* inherited statuses will be recomputed later.
2687 * Also disable SRV_ADMF_HMAINT flag (set from stats socket fqdn).
2688 */
2689 srv_admin_state &= ~SRV_ADMF_IDRAIN & ~SRV_ADMF_IMAINT & ~SRV_ADMF_HMAINT;
Willy Tarreau757478e2016-11-03 19:22:19 +01002690
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002691 if ((p == params[2]) || errno == EINVAL || errno == ERANGE ||
2692 (srv_admin_state != 0 &&
2693 srv_admin_state != SRV_ADMF_FMAINT &&
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002694 srv_admin_state != SRV_ADMF_CMAINT &&
2695 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT) &&
Willy Tarreaue1bde142016-11-03 18:33:25 +01002696 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FDRAIN) &&
Willy Tarreau757478e2016-11-03 19:22:19 +01002697 srv_admin_state != SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002698 chunk_appendf(msg, ", invalid srv_admin_state value '%s'", params[2]);
2699 }
2700
2701 /* validating srv_uweight */
2702 p = NULL;
2703 errno = 0;
2704 srv_uweight = strtol(params[3], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002705 if ((p == params[3]) || errno == EINVAL || errno == ERANGE || (srv_uweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002706 chunk_appendf(msg, ", invalid srv_uweight value '%s'", params[3]);
2707
2708 /* validating srv_iweight */
2709 p = NULL;
2710 errno = 0;
2711 srv_iweight = strtol(params[4], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002712 if ((p == params[4]) || errno == EINVAL || errno == ERANGE || (srv_iweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002713 chunk_appendf(msg, ", invalid srv_iweight value '%s'", params[4]);
2714
2715 /* validating srv_last_time_change */
2716 p = NULL;
2717 errno = 0;
2718 srv_last_time_change = strtol(params[5], &p, 10);
2719 if ((p == params[5]) || errno == EINVAL || errno == ERANGE)
2720 chunk_appendf(msg, ", invalid srv_last_time_change value '%s'", params[5]);
2721
2722 /* validating srv_check_status */
2723 p = NULL;
2724 errno = 0;
2725 srv_check_status = strtol(params[6], &p, 10);
2726 if (p == params[6] || errno == EINVAL || errno == ERANGE ||
2727 (srv_check_status >= HCHK_STATUS_SIZE))
2728 chunk_appendf(msg, ", invalid srv_check_status value '%s'", params[6]);
2729
2730 /* validating srv_check_result */
2731 p = NULL;
2732 errno = 0;
2733 srv_check_result = strtol(params[7], &p, 10);
2734 if ((p == params[7]) || errno == EINVAL || errno == ERANGE ||
2735 (srv_check_result != CHK_RES_UNKNOWN &&
2736 srv_check_result != CHK_RES_NEUTRAL &&
2737 srv_check_result != CHK_RES_FAILED &&
2738 srv_check_result != CHK_RES_PASSED &&
2739 srv_check_result != CHK_RES_CONDPASS)) {
2740 chunk_appendf(msg, ", invalid srv_check_result value '%s'", params[7]);
2741 }
2742
2743 /* validating srv_check_health */
2744 p = NULL;
2745 errno = 0;
2746 srv_check_health = strtol(params[8], &p, 10);
2747 if (p == params[8] || errno == EINVAL || errno == ERANGE)
2748 chunk_appendf(msg, ", invalid srv_check_health value '%s'", params[8]);
2749
2750 /* validating srv_check_state */
2751 p = NULL;
2752 errno = 0;
2753 srv_check_state = strtol(params[9], &p, 10);
2754 if (p == params[9] || errno == EINVAL || errno == ERANGE ||
2755 (srv_check_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2756 chunk_appendf(msg, ", invalid srv_check_state value '%s'", params[9]);
2757
2758 /* validating srv_agent_state */
2759 p = NULL;
2760 errno = 0;
2761 srv_agent_state = strtol(params[10], &p, 10);
2762 if (p == params[10] || errno == EINVAL || errno == ERANGE ||
2763 (srv_agent_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2764 chunk_appendf(msg, ", invalid srv_agent_state value '%s'", params[10]);
2765
2766 /* validating bk_f_forced_id */
2767 p = NULL;
2768 errno = 0;
2769 bk_f_forced_id = strtol(params[11], &p, 10);
2770 if (p == params[11] || errno == EINVAL || errno == ERANGE || !((bk_f_forced_id == 0) || (bk_f_forced_id == 1)))
2771 chunk_appendf(msg, ", invalid bk_f_forced_id value '%s'", params[11]);
2772
2773 /* validating srv_f_forced_id */
2774 p = NULL;
2775 errno = 0;
2776 srv_f_forced_id = strtol(params[12], &p, 10);
2777 if (p == params[12] || errno == EINVAL || errno == ERANGE || !((srv_f_forced_id == 0) || (srv_f_forced_id == 1)))
2778 chunk_appendf(msg, ", invalid srv_f_forced_id value '%s'", params[12]);
2779
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002780 /* validating srv_fqdn */
2781 fqdn = params[13];
2782 if (fqdn && *fqdn == '-')
2783 fqdn = NULL;
2784 if (fqdn && (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn))) {
2785 chunk_appendf(msg, ", invalid srv_fqdn value '%s'", params[13]);
2786 fqdn = NULL;
2787 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002788
Frédéric Lécaille31694712017-08-01 08:47:19 +02002789 port_str = params[14];
2790 if (port_str) {
2791 port = strl2uic(port_str, strlen(port_str));
2792 if (port > USHRT_MAX) {
2793 chunk_appendf(msg, ", invalid srv_port value '%s'", port_str);
2794 port_str = NULL;
2795 }
2796 }
2797
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002798 /* don't apply anything if one error has been detected */
Willy Tarreau31138fa2015-09-29 18:38:47 +02002799 if (msg->len)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002800 goto out;
2801
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002802 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002803 /* recover operational state and apply it to this server
2804 * and all servers tracking this one */
2805 switch (srv_op_state) {
2806 case SRV_ST_STOPPED:
2807 srv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02002808 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002809 break;
2810 case SRV_ST_STARTING:
Emeric Brun52a91d32017-08-31 14:41:55 +02002811 srv->next_state = srv_op_state;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002812 break;
2813 case SRV_ST_STOPPING:
2814 srv->check.health = srv->check.rise + srv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02002815 srv_set_stopping(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002816 break;
2817 case SRV_ST_RUNNING:
2818 srv->check.health = srv->check.rise + srv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02002819 srv_set_running(srv, "", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002820 break;
2821 }
2822
2823 /* When applying server state, the following rules apply:
2824 * - in case of a configuration change, we apply the setting from the new
2825 * configuration, regardless of old running state
2826 * - if no configuration change, we apply old running state only if old running
2827 * state is different from new configuration state
2828 */
2829 /* configuration has changed */
Emeric Brun52a91d32017-08-31 14:41:55 +02002830 if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->next_admin & SRV_ADMF_CMAINT)) {
2831 if (srv->next_admin & SRV_ADMF_CMAINT)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002832 srv_adm_set_maint(srv);
2833 else
2834 srv_adm_set_ready(srv);
2835 }
2836 /* configuration is the same, let's compate old running state and new conf state */
2837 else {
Emeric Brun52a91d32017-08-31 14:41:55 +02002838 if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002839 srv_adm_set_maint(srv);
Emeric Brun52a91d32017-08-31 14:41:55 +02002840 else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002841 srv_adm_set_ready(srv);
2842 }
2843 /* apply drain mode if server is currently enabled */
Emeric Brun52a91d32017-08-31 14:41:55 +02002844 if (!(srv->next_admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002845 /* The SRV_ADMF_FDRAIN flag is inherited when srv->iweight is 0
Willy Tarreau22cace22016-11-03 18:19:49 +01002846 * (srv->iweight is the weight set up in configuration).
2847 * There are two possible reasons for FDRAIN to have been present :
2848 * - previous config weight was zero
2849 * - "set server b/s drain" was sent to the CLI
2850 *
2851 * In the first case, we simply want to drop this drain state
2852 * if the new weight is not zero anymore, meaning the administrator
2853 * has intentionally turned the weight back to a positive value to
2854 * enable the server again after an operation. In the second case,
2855 * the drain state was forced on the CLI regardless of the config's
2856 * weight so we don't want a change to the config weight to lose this
2857 * status. What this means is :
2858 * - if previous weight was 0 and new one is >0, drop the DRAIN state.
2859 * - if the previous weight was >0, keep it.
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002860 */
Willy Tarreau22cace22016-11-03 18:19:49 +01002861 if (srv_iweight > 0 || srv->iweight == 0)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002862 srv_adm_set_drain(srv);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002863 }
2864
2865 srv->last_change = date.tv_sec - srv_last_time_change;
2866 srv->check.status = srv_check_status;
2867 srv->check.result = srv_check_result;
2868 srv->check.health = srv_check_health;
2869
2870 /* Only case we want to apply is removing ENABLED flag which could have been
2871 * done by the "disable health" command over the stats socket
2872 */
2873 if ((srv->check.state & CHK_ST_CONFIGURED) &&
2874 (srv_check_state & CHK_ST_CONFIGURED) &&
2875 !(srv_check_state & CHK_ST_ENABLED))
2876 srv->check.state &= ~CHK_ST_ENABLED;
2877
2878 /* Only case we want to apply is removing ENABLED flag which could have been
2879 * done by the "disable agent" command over the stats socket
2880 */
2881 if ((srv->agent.state & CHK_ST_CONFIGURED) &&
2882 (srv_agent_state & CHK_ST_CONFIGURED) &&
2883 !(srv_agent_state & CHK_ST_ENABLED))
2884 srv->agent.state &= ~CHK_ST_ENABLED;
2885
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002886 /* We want to apply the previous 'running' weight (srv_uweight) only if there
2887 * was no change in the configuration: both previous and new iweight are equals
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002888 *
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002889 * It means that a configuration file change has precedence over a unix socket change
2890 * for server's weight
2891 *
2892 * by default, HAProxy applies the following weight when parsing the configuration
2893 * srv->uweight = srv->iweight
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002894 */
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02002895 if (srv_iweight == srv->iweight) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002896 srv->uweight = srv_uweight;
2897 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002898 server_recalc_eweight(srv);
2899
Willy Tarreaue5a60682016-11-09 14:54:53 +01002900 /* load server IP address */
2901 srv->lastaddr = strdup(params[0]);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002902
2903 if (fqdn && srv->hostname) {
2904 if (!strcmp(srv->hostname, fqdn)) {
2905 /* Here we reset the 'set from stats socket FQDN' flag
2906 * to support such transitions:
2907 * Let's say initial FQDN value is foo1 (in configuration file).
2908 * - FQDN changed from stats socket, from foo1 to foo2 value,
2909 * - FQDN changed again from file configuration (with the same previous value
2910 set from stats socket, from foo1 to foo2 value),
2911 * - reload for any other reason than a FQDN modification,
2912 * the configuration file FQDN matches the fqdn server state file value.
2913 * So we must reset the 'set from stats socket FQDN' flag to be consistent with
2914 * any futher FQDN modification.
2915 */
Emeric Brun52a91d32017-08-31 14:41:55 +02002916 srv->next_admin &= ~SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002917 }
2918 else {
2919 /* If the FDQN has been changed from stats socket,
2920 * apply fqdn state file value (which is the value set
2921 * from stats socket).
2922 */
2923 if (fqdn_set_by_cli) {
Olivier Houchardd16bfe62017-10-31 15:21:19 +01002924 srv_set_fqdn(srv, fqdn, 0);
Emeric Brun52a91d32017-08-31 14:41:55 +02002925 srv->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002926 }
2927 }
2928 }
2929
Frédéric Lécaille31694712017-08-01 08:47:19 +02002930 if (port_str)
2931 srv->svc_port = port;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002932 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Frédéric Lécaille31694712017-08-01 08:47:19 +02002933
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002934 break;
2935 default:
2936 chunk_appendf(msg, ", version '%d' not supported", version);
2937 }
2938
2939 out:
Baptiste Assmann0821bb92016-01-21 00:20:50 +01002940 if (msg->len) {
2941 chunk_appendf(msg, "\n");
Christopher Faulet767a84b2017-11-24 16:50:31 +01002942 ha_warning("server-state application failed for server '%s/%s'%s",
2943 srv->proxy->id, srv->id, msg->str);
Baptiste Assmann0821bb92016-01-21 00:20:50 +01002944 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002945}
2946
2947/* This function parses all the proxies and only take care of the backends (since we're looking for server)
2948 * For each proxy, it does the following:
2949 * - opens its server state file (either one or local one)
2950 * - read whole file, line by line
2951 * - analyse each line to check if it matches our current backend:
2952 * - backend name matches
2953 * - backend id matches if id is forced and name doesn't match
2954 * - if the server pointed by the line is found, then state is applied
2955 *
2956 * If the running backend uuid or id differs from the state file, then HAProxy reports
2957 * a warning.
2958 */
2959void apply_server_state(void)
2960{
2961 char *cur, *end;
2962 char mybuf[SRV_STATE_LINE_MAXLEN];
2963 int mybuflen;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002964 char *params[SRV_STATE_FILE_MAX_FIELDS] = {0};
2965 char *srv_params[SRV_STATE_FILE_MAX_FIELDS] = {0};
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002966 int arg, srv_arg, version, diff;
2967 FILE *f;
2968 char *filepath;
2969 char globalfilepath[MAXPATHLEN + 1];
2970 char localfilepath[MAXPATHLEN + 1];
2971 int len, fileopenerr, globalfilepathlen, localfilepathlen;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002972 struct proxy *curproxy, *bk;
2973 struct server *srv;
2974
2975 globalfilepathlen = 0;
2976 /* create the globalfilepath variable */
2977 if (global.server_state_file) {
2978 /* absolute path or no base directory provided */
2979 if ((global.server_state_file[0] == '/') || (!global.server_state_base)) {
2980 len = strlen(global.server_state_file);
2981 if (len > MAXPATHLEN) {
2982 globalfilepathlen = 0;
2983 goto globalfileerror;
2984 }
2985 memcpy(globalfilepath, global.server_state_file, len);
2986 globalfilepath[len] = '\0';
2987 globalfilepathlen = len;
2988 }
2989 else if (global.server_state_base) {
2990 len = strlen(global.server_state_base);
2991 globalfilepathlen += len;
2992
2993 if (globalfilepathlen > MAXPATHLEN) {
2994 globalfilepathlen = 0;
2995 goto globalfileerror;
2996 }
2997 strncpy(globalfilepath, global.server_state_base, len);
2998 globalfilepath[globalfilepathlen] = 0;
2999
3000 /* append a slash if needed */
3001 if (!globalfilepathlen || globalfilepath[globalfilepathlen - 1] != '/') {
3002 if (globalfilepathlen + 1 > MAXPATHLEN) {
3003 globalfilepathlen = 0;
3004 goto globalfileerror;
3005 }
3006 globalfilepath[globalfilepathlen++] = '/';
3007 }
3008
3009 len = strlen(global.server_state_file);
3010 if (globalfilepathlen + len > MAXPATHLEN) {
3011 globalfilepathlen = 0;
3012 goto globalfileerror;
3013 }
3014 memcpy(globalfilepath + globalfilepathlen, global.server_state_file, len);
3015 globalfilepathlen += len;
3016 globalfilepath[globalfilepathlen++] = 0;
3017 }
3018 }
3019 globalfileerror:
3020 if (globalfilepathlen == 0)
3021 globalfilepath[0] = '\0';
3022
3023 /* read servers state from local file */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003024 for (curproxy = proxies_list; curproxy != NULL; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003025 /* servers are only in backends */
3026 if (!(curproxy->cap & PR_CAP_BE))
3027 continue;
3028 fileopenerr = 0;
3029 filepath = NULL;
3030
3031 /* search server state file path and name */
3032 switch (curproxy->load_server_state_from_file) {
3033 /* read servers state from global file */
3034 case PR_SRV_STATE_FILE_GLOBAL:
3035 /* there was an error while generating global server state file path */
3036 if (globalfilepathlen == 0)
3037 continue;
3038 filepath = globalfilepath;
3039 fileopenerr = 1;
3040 break;
3041 /* this backend has its own file */
3042 case PR_SRV_STATE_FILE_LOCAL:
3043 localfilepathlen = 0;
3044 localfilepath[0] = '\0';
3045 len = 0;
3046 /* create the localfilepath variable */
3047 /* absolute path or no base directory provided */
3048 if ((curproxy->server_state_file_name[0] == '/') || (!global.server_state_base)) {
3049 len = strlen(curproxy->server_state_file_name);
3050 if (len > MAXPATHLEN) {
3051 localfilepathlen = 0;
3052 goto localfileerror;
3053 }
3054 memcpy(localfilepath, curproxy->server_state_file_name, len);
3055 localfilepath[len] = '\0';
3056 localfilepathlen = len;
3057 }
3058 else if (global.server_state_base) {
3059 len = strlen(global.server_state_base);
3060 localfilepathlen += len;
3061
3062 if (localfilepathlen > MAXPATHLEN) {
3063 localfilepathlen = 0;
3064 goto localfileerror;
3065 }
3066 strncpy(localfilepath, global.server_state_base, len);
3067 localfilepath[localfilepathlen] = 0;
3068
3069 /* append a slash if needed */
3070 if (!localfilepathlen || localfilepath[localfilepathlen - 1] != '/') {
3071 if (localfilepathlen + 1 > MAXPATHLEN) {
3072 localfilepathlen = 0;
3073 goto localfileerror;
3074 }
3075 localfilepath[localfilepathlen++] = '/';
3076 }
3077
3078 len = strlen(curproxy->server_state_file_name);
3079 if (localfilepathlen + len > MAXPATHLEN) {
3080 localfilepathlen = 0;
3081 goto localfileerror;
3082 }
3083 memcpy(localfilepath + localfilepathlen, curproxy->server_state_file_name, len);
3084 localfilepathlen += len;
3085 localfilepath[localfilepathlen++] = 0;
3086 }
3087 filepath = localfilepath;
3088 localfileerror:
3089 if (localfilepathlen == 0)
3090 localfilepath[0] = '\0';
3091
3092 break;
3093 case PR_SRV_STATE_FILE_NONE:
3094 default:
3095 continue;
3096 }
3097
3098 /* preload global state file */
3099 errno = 0;
3100 f = fopen(filepath, "r");
3101 if (errno && fileopenerr)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003102 ha_warning("Can't open server state file '%s': %s\n", filepath, strerror(errno));
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003103 if (!f)
3104 continue;
3105
3106 mybuf[0] = '\0';
3107 mybuflen = 0;
3108 version = 0;
3109
3110 /* first character of first line of the file must contain the version of the export */
Dragan Dosencf4fb032015-11-04 23:03:26 +01003111 if (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003112 ha_warning("Can't read first line of the server state file '%s'\n", filepath);
Dragan Dosencf4fb032015-11-04 23:03:26 +01003113 goto fileclose;
3114 }
3115
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003116 cur = mybuf;
3117 version = atoi(cur);
3118 if ((version < SRV_STATE_FILE_VERSION_MIN) ||
3119 (version > SRV_STATE_FILE_VERSION_MAX))
Dragan Dosencf4fb032015-11-04 23:03:26 +01003120 goto fileclose;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003121
3122 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3123 int bk_f_forced_id = 0;
3124 int check_id = 0;
3125 int check_name = 0;
3126
3127 mybuflen = strlen(mybuf);
3128 cur = mybuf;
3129 end = cur + mybuflen;
3130
3131 bk = NULL;
3132 srv = NULL;
3133
3134 /* we need at least one character */
3135 if (mybuflen == 0)
3136 continue;
3137
3138 /* ignore blank characters at the beginning of the line */
3139 while (isspace(*cur))
3140 ++cur;
3141
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003142 /* Ignore empty or commented lines */
3143 if (cur == end || *cur == '#')
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003144 continue;
3145
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003146 /* truncated lines */
3147 if (mybuf[mybuflen - 1] != '\n') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003148 ha_warning("server-state file '%s': truncated line\n", filepath);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003149 continue;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003150 }
3151
3152 /* Removes trailing '\n' */
3153 mybuf[mybuflen - 1] = '\0';
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003154
3155 /* we're now ready to move the line into *srv_params[] */
3156 params[0] = cur;
3157 arg = 1;
3158 srv_arg = 0;
3159 while (*cur && arg < SRV_STATE_FILE_MAX_FIELDS) {
3160 if (isspace(*cur)) {
3161 *cur = '\0';
3162 ++cur;
3163 while (isspace(*cur))
3164 ++cur;
3165 switch (version) {
3166 case 1:
3167 /*
3168 * srv_addr: params[4] => srv_params[0]
3169 * srv_op_state: params[5] => srv_params[1]
3170 * srv_admin_state: params[6] => srv_params[2]
3171 * srv_uweight: params[7] => srv_params[3]
3172 * srv_iweight: params[8] => srv_params[4]
3173 * srv_last_time_change: params[9] => srv_params[5]
3174 * srv_check_status: params[10] => srv_params[6]
3175 * srv_check_result: params[11] => srv_params[7]
3176 * srv_check_health: params[12] => srv_params[8]
3177 * srv_check_state: params[13] => srv_params[9]
3178 * srv_agent_state: params[14] => srv_params[10]
3179 * bk_f_forced_id: params[15] => srv_params[11]
3180 * srv_f_forced_id: params[16] => srv_params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003181 * srv_fqdn: params[17] => srv_params[13]
Frédéric Lécaille31694712017-08-01 08:47:19 +02003182 * srv_port: params[18] => srv_params[14]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003183 */
3184 if (arg >= 4) {
3185 srv_params[srv_arg] = cur;
3186 ++srv_arg;
3187 }
3188 break;
3189 }
3190
3191 params[arg] = cur;
3192 ++arg;
3193 }
3194 else {
3195 ++cur;
3196 }
3197 }
3198
3199 /* if line is incomplete line, then ignore it.
3200 * otherwise, update useful flags */
3201 switch (version) {
3202 case 1:
3203 if (arg < SRV_STATE_FILE_NB_FIELDS_VERSION_1)
3204 continue;
3205 bk_f_forced_id = (atoi(params[15]) & PR_O_FORCED_ID);
3206 check_id = (atoi(params[0]) == curproxy->uuid);
3207 check_name = (strcmp(curproxy->id, params[1]) == 0);
3208 break;
3209 }
3210
3211 diff = 0;
3212 bk = curproxy;
3213
3214 /* if backend can't be found, let's continue */
3215 if (!check_id && !check_name)
3216 continue;
3217 else if (!check_id && check_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003218 ha_warning("backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003219 send_log(bk, LOG_NOTICE, "backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3220 }
3221 else if (check_id && !check_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003222 ha_warning("backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003223 send_log(bk, LOG_NOTICE, "backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3224 /* if name doesn't match, we still want to update curproxy if the backend id
3225 * was forced in previous the previous configuration */
3226 if (!bk_f_forced_id)
3227 continue;
3228 }
3229
3230 /* look for the server by its id: param[2] */
3231 /* else look for the server by its name: param[3] */
3232 diff = 0;
3233 srv = server_find_best_match(bk, params[3], atoi(params[2]), &diff);
3234
3235 if (!srv) {
3236 /* if no server found, then warning and continue with next line */
Christopher Faulet767a84b2017-11-24 16:50:31 +01003237 ha_warning("can't find server '%s' with id '%s' in backend with id '%s' or name '%s'\n",
3238 params[3], params[2], params[0], params[1]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003239 send_log(bk, LOG_NOTICE, "can't find server '%s' with id '%s' in backend with id '%s' or name '%s'\n",
3240 params[3], params[2], params[0], params[1]);
3241 continue;
3242 }
3243 else if (diff & PR_FBM_MISMATCH_ID) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003244 ha_warning("In backend '%s' (id: '%d'): server ID mismatch: from server state file: '%s', from running config %d\n", bk->id, bk->uuid, params[2], srv->puid);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003245 send_log(bk, LOG_NOTICE, "In backend '%s' (id: %d): server ID mismatch: from server state file: '%s', from running config %d\n", bk->id, bk->uuid, params[2], srv->puid);
Frédéric Lécaille0bedb8a2017-06-15 14:09:10 +02003246 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003247 }
3248 else if (diff & PR_FBM_MISMATCH_NAME) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003249 ha_warning("In backend '%s' (id: %d): server name mismatch: from server state file: '%s', from running config '%s'\n", bk->id, bk->uuid, params[3], srv->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003250 send_log(bk, LOG_NOTICE, "In backend '%s' (id: %d): server name mismatch: from server state file: '%s', from running config '%s'\n", bk->id, bk->uuid, params[3], srv->id);
Frédéric Lécaille0bedb8a2017-06-15 14:09:10 +02003251 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003252 }
3253
3254 /* now we can proceed with server's state update */
3255 srv_update_state(srv, version, srv_params);
3256 }
Dragan Dosencf4fb032015-11-04 23:03:26 +01003257fileclose:
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003258 fclose(f);
3259 }
3260}
3261
Simon Horman7d09b9a2013-02-12 10:45:51 +09003262/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02003263 * update a server's current IP address.
3264 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
3265 * ip is in network format.
3266 * updater is a string which contains an information about the requester of the update.
3267 * updater is used if not NULL.
3268 *
3269 * A log line and a stderr warning message is generated based on server's backend options.
3270 */
Thierry Fournierd35b7a62016-02-24 08:23:22 +01003271int update_server_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02003272{
3273 /* generates a log line and a warning on stderr */
3274 if (1) {
3275 /* book enough space for both IPv4 and IPv6 */
3276 char oldip[INET6_ADDRSTRLEN];
3277 char newip[INET6_ADDRSTRLEN];
3278
3279 memset(oldip, '\0', INET6_ADDRSTRLEN);
3280 memset(newip, '\0', INET6_ADDRSTRLEN);
3281
3282 /* copy old IP address in a string */
3283 switch (s->addr.ss_family) {
3284 case AF_INET:
3285 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
3286 break;
3287 case AF_INET6:
3288 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
3289 break;
3290 };
3291
3292 /* copy new IP address in a string */
3293 switch (ip_sin_family) {
3294 case AF_INET:
3295 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
3296 break;
3297 case AF_INET6:
3298 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
3299 break;
3300 };
3301
3302 /* save log line into a buffer */
3303 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
3304 s->proxy->id, s->id, oldip, newip, updater);
3305
3306 /* write the buffer on stderr */
Christopher Faulet767a84b2017-11-24 16:50:31 +01003307 ha_warning("%s.\n", trash.str);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003308
3309 /* send a log */
3310 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
3311 }
3312
3313 /* save the new IP family */
3314 s->addr.ss_family = ip_sin_family;
3315 /* save the new IP address */
3316 switch (ip_sin_family) {
3317 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02003318 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003319 break;
3320 case AF_INET6:
3321 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
3322 break;
3323 };
Olivier Houchard4e694042017-03-14 20:01:29 +01003324 srv_set_dyncookie(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003325
3326 return 0;
3327}
3328
3329/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003330 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3331 *
3332 * Caller can pass its name through <updater> to get it integrated in the response message
3333 * returned by the function.
3334 *
3335 * The function first does the following, in that order:
3336 * - validates the new addr and/or port
3337 * - checks if an update is required (new IP or port is different than current ones)
3338 * - checks the update is allowed:
3339 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3340 * - allow all changes if no CHECKS are configured
3341 * - if CHECK is configured:
3342 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3343 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3344 * conditions are met
3345 */
3346const char *update_server_addr_port(struct server *s, const char *addr, const char *port, char *updater)
3347{
3348 struct sockaddr_storage sa;
3349 int ret, port_change_required;
3350 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003351 uint16_t current_port, new_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003352 struct chunk *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003353 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003354
3355 msg = get_trash_chunk();
3356 chunk_reset(msg);
3357
3358 if (addr) {
3359 memset(&sa, 0, sizeof(struct sockaddr_storage));
3360 if (str2ip2(addr, &sa, 0) == NULL) {
3361 chunk_printf(msg, "Invalid addr '%s'", addr);
3362 goto out;
3363 }
3364
3365 /* changes are allowed on AF_INET* families only */
3366 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3367 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3368 goto out;
3369 }
3370
3371 /* collecting data currently setup */
3372 memset(current_addr, '\0', sizeof(current_addr));
3373 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3374 /* changes are allowed on AF_INET* families only */
3375 if ((ret != AF_INET) && (ret != AF_INET6)) {
3376 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3377 goto out;
3378 }
3379
3380 /* applying ADDR changes if required and allowed
3381 * ipcmp returns 0 when both ADDR are the same
3382 */
3383 if (ipcmp(&s->addr, &sa) == 0) {
3384 chunk_appendf(msg, "no need to change the addr");
3385 goto port;
3386 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003387 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003388 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003389
3390 /* we also need to update check's ADDR only if it uses the server's one */
3391 if ((s->check.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_CHECKADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003392 ipcpy(&sa, &s->check.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003393 }
3394
3395 /* we also need to update agent ADDR only if it use the server's one */
3396 if ((s->agent.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_AGENTADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003397 ipcpy(&sa, &s->agent.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003398 }
3399
3400 /* update report for caller */
3401 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3402 }
3403
3404 port:
3405 if (port) {
3406 char sign = '\0';
3407 char *endptr;
3408
3409 if (addr)
3410 chunk_appendf(msg, ", ");
3411
3412 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003413 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003414
3415 /* check if PORT change is required */
3416 port_change_required = 0;
3417
3418 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003419 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003420 new_port = strtol(port, &endptr, 10);
3421 if ((errno != 0) || (port == endptr)) {
3422 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3423 goto out;
3424 }
3425
3426 /* check if caller triggers a port mapped or offset */
3427 if (sign == '-' || (sign == '+')) {
3428 /* check if server currently uses port map */
3429 if (!(s->flags & SRV_F_MAPPORTS)) {
3430 /* switch from fixed port to port map mandatorily triggers
3431 * a port change */
3432 port_change_required = 1;
3433 /* check is configured
3434 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3435 * prevent PORT change if check doesn't have it's dedicated port while switching
3436 * to port mapping */
3437 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3438 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.");
3439 goto out;
3440 }
3441 }
3442 /* we're already using port maps */
3443 else {
3444 port_change_required = current_port != new_port;
3445 }
3446 }
3447 /* fixed port */
3448 else {
3449 port_change_required = current_port != new_port;
3450 }
3451
3452 /* applying PORT changes if required and update response message */
3453 if (port_change_required) {
3454 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003455 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003456 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003457
3458 /* prepare message */
3459 chunk_appendf(msg, "port changed from '");
3460 if (s->flags & SRV_F_MAPPORTS)
3461 chunk_appendf(msg, "+");
3462 chunk_appendf(msg, "%d' to '", current_port);
3463
3464 if (sign == '-') {
3465 s->flags |= SRV_F_MAPPORTS;
3466 chunk_appendf(msg, "%c", sign);
3467 /* just use for result output */
3468 new_port = -new_port;
3469 }
3470 else if (sign == '+') {
3471 s->flags |= SRV_F_MAPPORTS;
3472 chunk_appendf(msg, "%c", sign);
3473 }
3474 else {
3475 s->flags &= ~SRV_F_MAPPORTS;
3476 }
3477
3478 chunk_appendf(msg, "%d'", new_port);
3479
3480 /* we also need to update health checks port only if it uses server's realport */
3481 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3482 s->check.port = new_port;
3483 }
3484 }
3485 else {
3486 chunk_appendf(msg, "no need to change the port");
3487 }
3488 }
3489
3490out:
Olivier Houchard4e694042017-03-14 20:01:29 +01003491 if (changed)
3492 srv_set_dyncookie(s);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003493 if (updater)
3494 chunk_appendf(msg, " by '%s'", updater);
3495 chunk_appendf(msg, "\n");
3496 return msg->str;
3497}
3498
3499
3500/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003501 * update server status based on result of name resolution
3502 * returns:
3503 * 0 if server status is updated
3504 * 1 if server status has not changed
3505 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003506int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003507{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003508 struct dns_resolvers *resolvers = s->resolvers;
3509 struct dns_resolution *resolution = s->dns_requester->resolution;
3510 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003511
3512 switch (resolution->status) {
3513 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003514 /* status when HAProxy has just (re)started.
3515 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003516 break;
3517
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003518 case RSLV_STATUS_VALID:
3519 /*
3520 * resume health checks
3521 * server will be turned back on if health check is safe
3522 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003523 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003524 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003525 return 1;
3526 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3527 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003528 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003529 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003530
Emeric Brun52a91d32017-08-31 14:41:55 +02003531 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003532 return 1;
3533 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3534 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3535 s->proxy->id, s->id);
3536
Christopher Faulet767a84b2017-11-24 16:50:31 +01003537 ha_warning("%s.\n", trash.str);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003538 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
3539 return 0;
3540
3541 case RSLV_STATUS_NX:
3542 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003543 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3544 if (!tick_is_expired(exp, now_ms))
3545 break;
3546
3547 if (s->next_admin & SRV_ADMF_RMAINT)
3548 return 1;
3549 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3550 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003551
3552 case RSLV_STATUS_TIMEOUT:
3553 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003554 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3555 if (!tick_is_expired(exp, now_ms))
3556 break;
3557
3558 if (s->next_admin & SRV_ADMF_RMAINT)
3559 return 1;
3560 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3561 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003562
3563 case RSLV_STATUS_REFUSED:
3564 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003565 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3566 if (!tick_is_expired(exp, now_ms))
3567 break;
3568
3569 if (s->next_admin & SRV_ADMF_RMAINT)
3570 return 1;
3571 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3572 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003573
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003574 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003575 /* stop server if resolution failed for a long enough period */
3576 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3577 if (!tick_is_expired(exp, now_ms))
3578 break;
3579
3580 if (s->next_admin & SRV_ADMF_RMAINT)
3581 return 1;
3582 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3583 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003584 }
3585
3586 return 1;
3587}
3588
3589/*
3590 * Server Name Resolution valid response callback
3591 * It expects:
3592 * - <nameserver>: the name server which answered the valid response
3593 * - <response>: buffer containing a valid DNS response
3594 * - <response_len>: size of <response>
3595 * It performs the following actions:
3596 * - ignore response if current ip found and server family not met
3597 * - update with first new ip found if family is met and current IP is not found
3598 * returns:
3599 * 0 on error
3600 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003601 *
3602 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003603 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003604int snr_resolution_cb(struct dns_requester *requester, struct dns_nameserver *nameserver)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003605{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003606 struct server *s = NULL;
3607 struct dns_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003608 void *serverip, *firstip;
3609 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003610 int ret;
3611 struct chunk *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003612 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003613
Christopher Faulet67957bd2017-09-27 11:00:59 +02003614 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003615 if (!s)
3616 return 1;
3617
Christopher Faulet67957bd2017-09-27 11:00:59 +02003618 resolution = s->dns_requester->resolution;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003619
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003620 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003621 firstip = NULL; /* pointer to the first valid response found */
3622 /* it will be used as the new IP if a change is required */
3623 firstip_sin_family = AF_UNSPEC;
3624 serverip = NULL; /* current server IP address */
3625
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003626 /* initializing server IP pointer */
3627 server_sin_family = s->addr.ss_family;
3628 switch (server_sin_family) {
3629 case AF_INET:
3630 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3631 break;
3632
3633 case AF_INET6:
3634 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3635 break;
3636
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003637 case AF_UNSPEC:
3638 break;
3639
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003640 default:
3641 goto invalid;
3642 }
3643
Baptiste Assmann729c9012017-05-22 15:13:10 +02003644 ret = dns_get_ip_from_response(&resolution->response, &s->dns_opts,
Thierry Fournierada34842016-02-17 21:25:09 +01003645 serverip, server_sin_family, &firstip,
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003646 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003647
3648 switch (ret) {
3649 case DNS_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003650 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003651
3652 case DNS_UPD_SRVIP_NOT_FOUND:
3653 goto save_ip;
3654
3655 case DNS_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003656 goto invalid;
3657
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003658 case DNS_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003659 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003660 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003661
Baptiste Assmannfad03182015-10-28 02:03:32 +01003662 case DNS_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003663 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003664 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003665 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003666
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003667 default:
3668 goto invalid;
3669
3670 }
3671
3672 save_ip:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003673 if (nameserver) {
3674 nameserver->counters.update++;
3675 /* save the first ip we found */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003676 chunk_printf(chk, "%s/%s", nameserver->resolvers->id, nameserver->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003677 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003678 else
3679 chunk_printf(chk, "DNS cache");
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003680 update_server_addr(s, firstip, firstip_sin_family, (char *)chk->str);
3681
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003682 update_status:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003683 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003684 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003685
3686 invalid:
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003687 if (nameserver) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02003688 nameserver->counters.invalid++;
3689 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003690 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003691 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003692 return 0;
3693}
3694
3695/*
3696 * Server Name Resolution error management callback
3697 * returns:
3698 * 0 on error
3699 * 1 when no error or safe ignore
3700 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003701int snr_resolution_error_cb(struct dns_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003702{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003703 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003704
Christopher Faulet67957bd2017-09-27 11:00:59 +02003705 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003706 if (!s)
3707 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003708 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003709 snr_update_srv_status(s, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003710 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003711 return 1;
3712}
3713
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003714/*
3715 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003716 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003717 * It returns a pointer to the first server found or NULL if <ip> is not yet
3718 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003719 *
3720 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003721 */
3722struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3723{
3724 struct server *tmpsrv;
3725 struct proxy *be;
3726
3727 if (!srv)
3728 return NULL;
3729
3730 be = srv->proxy;
3731 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003732 /* we found the current server is the same, ignore it */
3733 if (srv == tmpsrv)
3734 continue;
3735
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003736 /* We want to compare the IP in the record with the IP of the servers in the
3737 * same backend, only if:
3738 * * DNS resolution is enabled on the server
3739 * * the hostname used for the resolution by our server is the same than the
3740 * one used for the server found in the backend
3741 * * the server found in the backend is not our current server
3742 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003743 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003744 if ((tmpsrv->hostname_dn == NULL) ||
3745 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
3746 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01003747 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003748 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003749 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003750 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003751
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003752 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01003753 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003754 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003755 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003756 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003757
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003758 /* At this point, we have 2 different servers using the same DNS hostname
3759 * for their respective resolution.
3760 */
3761 if (*ip_family == tmpsrv->addr.ss_family &&
3762 ((tmpsrv->addr.ss_family == AF_INET &&
3763 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3764 (tmpsrv->addr.ss_family == AF_INET6 &&
3765 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003766 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003767 return tmpsrv;
3768 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003769 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003770 }
3771
Emeric Brune9fd6b52017-11-02 17:20:39 +01003772
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003773 return NULL;
3774}
3775
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003776/* Sets the server's address (srv->addr) from srv->hostname using the libc's
3777 * resolver. This is suited for initial address configuration. Returns 0 on
3778 * success otherwise a non-zero error code. In case of error, *err_code, if
3779 * not NULL, is filled up.
3780 */
3781int srv_set_addr_via_libc(struct server *srv, int *err_code)
3782{
3783 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003784 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01003785 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003786 return 1;
3787 }
3788 return 0;
3789}
3790
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003791/* Set the server's FDQN (->hostname) from <hostname>.
3792 * Returns -1 if failed, 0 if not.
3793 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01003794int srv_set_fqdn(struct server *srv, const char *hostname, int dns_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003795{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003796 struct dns_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003797 char *hostname_dn;
3798 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003799
Olivier Houchardd16bfe62017-10-31 15:21:19 +01003800 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003801 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003802 /* run time DNS resolution was not active for this server
3803 * and we can't enable it at run time for now.
3804 */
3805 if (!srv->dns_requester)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003806 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003807
3808 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003809 hostname_len = strlen(hostname);
3810 hostname_dn = trash.str;
3811 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
3812 hostname_dn, trash.size);
3813 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003814 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003815
Christopher Faulet67957bd2017-09-27 11:00:59 +02003816 resolution = srv->dns_requester->resolution;
3817 if (resolution &&
3818 resolution->hostname_dn &&
3819 !strcmp(resolution->hostname_dn, hostname_dn))
Christopher Fauletb2812a62017-10-04 16:17:58 +02003820 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003821
Christopher Faulet67957bd2017-09-27 11:00:59 +02003822 dns_unlink_resolution(srv->dns_requester);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003823
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003824 free(srv->hostname);
3825 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003826 srv->hostname = strdup(hostname);
3827 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003828 srv->hostname_dn_len = hostname_dn_len;
3829 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003830 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003831
Olivier Houchard55dcdf42017-11-06 15:15:04 +01003832 if (dns_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003833 goto err;
3834
3835 end:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01003836 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003837 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003838 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02003839
3840 err:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01003841 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003842 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02003843 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003844}
3845
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003846/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
3847 * from the state file. This is suited for initial address configuration.
3848 * Returns 0 on success otherwise a non-zero error code. In case of error,
3849 * *err_code, if not NULL, is filled up.
3850 */
3851static int srv_apply_lastaddr(struct server *srv, int *err_code)
3852{
3853 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
3854 if (err_code)
3855 *err_code |= ERR_WARN;
3856 return 1;
3857 }
3858 return 0;
3859}
3860
Willy Tarreau25e51522016-11-04 15:10:17 +01003861/* returns 0 if no error, otherwise a combination of ERR_* flags */
3862static int srv_iterate_initaddr(struct server *srv)
3863{
3864 int return_code = 0;
3865 int err_code;
3866 unsigned int methods;
3867
3868 methods = srv->init_addr_methods;
3869 if (!methods) { // default to "last,libc"
3870 srv_append_initaddr(&methods, SRV_IADDR_LAST);
3871 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
3872 }
3873
Willy Tarreau3eed10e2016-11-07 21:03:16 +01003874 /* "-dr" : always append "none" so that server addresses resolution
3875 * failures are silently ignored, this is convenient to validate some
3876 * configs out of their environment.
3877 */
3878 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
3879 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3880
Willy Tarreau25e51522016-11-04 15:10:17 +01003881 while (methods) {
3882 err_code = 0;
3883 switch (srv_get_next_initaddr(&methods)) {
3884 case SRV_IADDR_LAST:
3885 if (!srv->lastaddr)
3886 continue;
3887 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003888 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003889 return_code |= err_code;
3890 break;
3891
3892 case SRV_IADDR_LIBC:
3893 if (!srv->hostname)
3894 continue;
3895 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003896 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003897 return_code |= err_code;
3898 break;
3899
Willy Tarreau37ebe122016-11-04 15:17:58 +01003900 case SRV_IADDR_NONE:
3901 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003902 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003903 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
3904 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003905 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01003906 return return_code;
3907
Willy Tarreau4310d362016-11-02 15:05:56 +01003908 case SRV_IADDR_IP:
3909 ipcpy(&srv->init_addr, &srv->addr);
3910 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003911 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', falling back to configured address.\n",
3912 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
Willy Tarreau4310d362016-11-02 15:05:56 +01003913 }
Olivier Houchard4e694042017-03-14 20:01:29 +01003914 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01003915
Willy Tarreau25e51522016-11-04 15:10:17 +01003916 default: /* unhandled method */
3917 break;
3918 }
3919 }
3920
3921 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003922 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Willy Tarreau25e51522016-11-04 15:10:17 +01003923 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
3924 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01003925 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003926 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Willy Tarreau465b6e52016-11-07 19:19:22 +01003927 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
3928 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003929
3930 return_code |= ERR_ALERT | ERR_FATAL;
3931 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01003932out:
3933 srv_set_dyncookie(srv);
3934 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01003935}
3936
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003937/*
3938 * This function parses all backends and all servers within each backend
3939 * and performs servers' addr resolution based on information provided by:
3940 * - configuration file
3941 * - server-state file (states provided by an 'old' haproxy process)
3942 *
3943 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
3944 */
3945int srv_init_addr(void)
3946{
3947 struct proxy *curproxy;
3948 int return_code = 0;
3949
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003950 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003951 while (curproxy) {
3952 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003953
3954 /* servers are in backend only */
3955 if (!(curproxy->cap & PR_CAP_BE))
3956 goto srv_init_addr_next;
3957
Willy Tarreau25e51522016-11-04 15:10:17 +01003958 for (srv = curproxy->srv; srv; srv = srv->next)
Willy Tarreau3d609a72017-09-06 14:22:45 +02003959 if (srv->hostname)
3960 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003961
3962 srv_init_addr_next:
3963 curproxy = curproxy->next;
3964 }
3965
3966 return return_code;
3967}
3968
Olivier Houchardd16bfe62017-10-31 15:21:19 +01003969const 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 +02003970{
3971
3972 struct chunk *msg;
3973
3974 msg = get_trash_chunk();
3975 chunk_reset(msg);
3976
Olivier Houchard8da5f982017-08-04 18:35:36 +02003977 if (server->hostname && !strcmp(fqdn, server->hostname)) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003978 chunk_appendf(msg, "no need to change the FDQN");
3979 goto out;
3980 }
3981
3982 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
3983 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
3984 goto out;
3985 }
3986
3987 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
3988 server->proxy->id, server->id, server->hostname, fqdn);
3989
Olivier Houchardd16bfe62017-10-31 15:21:19 +01003990 if (srv_set_fqdn(server, fqdn, dns_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003991 chunk_reset(msg);
3992 chunk_appendf(msg, "could not update %s/%s FQDN",
3993 server->proxy->id, server->id);
3994 goto out;
3995 }
3996
3997 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02003998 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003999
4000 out:
4001 if (updater)
4002 chunk_appendf(msg, " by '%s'", updater);
4003 chunk_appendf(msg, "\n");
4004
4005 return msg->str;
4006}
4007
4008
Willy Tarreau21b069d2016-11-23 17:15:08 +01004009/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
4010 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004011 * 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 +01004012 * used for CLI commands requiring a server name.
4013 * Important: the <arg> is modified to remove the '/'.
4014 */
4015struct server *cli_find_server(struct appctx *appctx, char *arg)
4016{
4017 struct proxy *px;
4018 struct server *sv;
4019 char *line;
4020
4021 /* split "backend/server" and make <line> point to server */
4022 for (line = arg; *line; line++)
4023 if (*line == '/') {
4024 *line++ = '\0';
4025 break;
4026 }
4027
4028 if (!*line || !*arg) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004029 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004030 appctx->ctx.cli.msg = "Require 'backend/server'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004031 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004032 return NULL;
4033 }
4034
4035 if (!get_backend_server(arg, line, &px, &sv)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004036 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004037 appctx->ctx.cli.msg = px ? "No such server.\n" : "No such backend.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004038 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004039 return NULL;
4040 }
4041
4042 if (px->state == PR_STSTOPPED) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004043 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004044 appctx->ctx.cli.msg = "Proxy is disabled.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004045 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004046 return NULL;
4047 }
4048
4049 return sv;
4050}
4051
William Lallemand222baf22016-11-19 02:00:33 +01004052
4053static int cli_parse_set_server(char **args, struct appctx *appctx, void *private)
4054{
4055 struct server *sv;
4056 const char *warning;
4057
4058 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4059 return 1;
4060
4061 sv = cli_find_server(appctx, args[2]);
4062 if (!sv)
4063 return 1;
4064
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004065 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02004066
William Lallemand222baf22016-11-19 02:00:33 +01004067 if (strcmp(args[3], "weight") == 0) {
4068 warning = server_parse_weight_change_request(sv, args[4]);
4069 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004070 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004071 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004072 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004073 }
4074 }
4075 else if (strcmp(args[3], "state") == 0) {
4076 if (strcmp(args[4], "ready") == 0)
4077 srv_adm_set_ready(sv);
4078 else if (strcmp(args[4], "drain") == 0)
4079 srv_adm_set_drain(sv);
4080 else if (strcmp(args[4], "maint") == 0)
4081 srv_adm_set_maint(sv);
4082 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004083 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004084 appctx->ctx.cli.msg = "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004085 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004086 }
4087 }
4088 else if (strcmp(args[3], "health") == 0) {
4089 if (sv->track) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004090 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004091 appctx->ctx.cli.msg = "cannot change health on a tracking server.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004092 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004093 }
4094 else if (strcmp(args[4], "up") == 0) {
4095 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004096 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004097 }
4098 else if (strcmp(args[4], "stopping") == 0) {
4099 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004100 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004101 }
4102 else if (strcmp(args[4], "down") == 0) {
4103 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004104 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004105 }
4106 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004107 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004108 appctx->ctx.cli.msg = "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004109 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004110 }
4111 }
4112 else if (strcmp(args[3], "agent") == 0) {
4113 if (!(sv->agent.state & CHK_ST_ENABLED)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004114 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004115 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004116 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004117 }
4118 else if (strcmp(args[4], "up") == 0) {
4119 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004120 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004121 }
4122 else if (strcmp(args[4], "down") == 0) {
4123 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004124 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004125 }
4126 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004127 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004128 appctx->ctx.cli.msg = "'set server <srv> agent' expects 'up' or 'down'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004129 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004130 }
4131 }
Misiek2da082d2017-01-09 09:40:42 +01004132 else if (strcmp(args[3], "agent-addr") == 0) {
4133 if (!(sv->agent.state & CHK_ST_ENABLED)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004134 appctx->ctx.cli.severity = LOG_ERR;
Misiek2da082d2017-01-09 09:40:42 +01004135 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
4136 appctx->st0 = CLI_ST_PRINT;
4137 } else {
4138 if (str2ip(args[4], &sv->agent.addr) == NULL) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004139 appctx->ctx.cli.severity = LOG_ERR;
Misiek2da082d2017-01-09 09:40:42 +01004140 appctx->ctx.cli.msg = "incorrect addr address given for agent.\n";
4141 appctx->st0 = CLI_ST_PRINT;
4142 }
4143 }
4144 }
4145 else if (strcmp(args[3], "agent-send") == 0) {
4146 if (!(sv->agent.state & CHK_ST_ENABLED)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004147 appctx->ctx.cli.severity = LOG_ERR;
Misiek2da082d2017-01-09 09:40:42 +01004148 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
4149 appctx->st0 = CLI_ST_PRINT;
4150 } else {
4151 char *nss = strdup(args[4]);
4152 if (!nss) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004153 appctx->ctx.cli.severity = LOG_ERR;
Misiek2da082d2017-01-09 09:40:42 +01004154 appctx->ctx.cli.msg = "cannot allocate memory for new string.\n";
4155 appctx->st0 = CLI_ST_PRINT;
4156 } else {
4157 free(sv->agent.send_string);
4158 sv->agent.send_string = nss;
4159 sv->agent.send_string_len = strlen(args[4]);
4160 }
4161 }
4162 }
William Lallemand222baf22016-11-19 02:00:33 +01004163 else if (strcmp(args[3], "check-port") == 0) {
4164 int i = 0;
4165 if (strl2irc(args[4], strlen(args[4]), &i) != 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004166 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004167 appctx->ctx.cli.msg = "'set server <srv> check-port' expects an integer as argument.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004168 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004169 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004170 }
4171 if ((i < 0) || (i > 65535)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004172 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004173 appctx->ctx.cli.msg = "provided port is not valid.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004174 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004175 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004176 }
4177 /* prevent the update of port to 0 if MAPPORTS are in use */
4178 if ((sv->flags & SRV_F_MAPPORTS) && (i == 0)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004179 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004180 appctx->ctx.cli.msg = "can't unset 'port' since MAPPORTS is in use.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004181 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004182 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004183 }
4184 sv->check.port = i;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004185 appctx->ctx.cli.severity = LOG_NOTICE;
William Lallemand222baf22016-11-19 02:00:33 +01004186 appctx->ctx.cli.msg = "health check port updated.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004187 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004188 }
4189 else if (strcmp(args[3], "addr") == 0) {
4190 char *addr = NULL;
4191 char *port = NULL;
4192 if (strlen(args[4]) == 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004193 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004194 appctx->ctx.cli.msg = "set server <b>/<s> addr requires an address and optionally a port.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004195 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004196 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004197 }
4198 else {
4199 addr = args[4];
4200 }
4201 if (strcmp(args[5], "port") == 0) {
4202 port = args[6];
4203 }
4204 warning = update_server_addr_port(sv, addr, port, "stats socket command");
4205 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004206 appctx->ctx.cli.severity = LOG_WARNING;
William Lallemand222baf22016-11-19 02:00:33 +01004207 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004208 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004209 }
4210 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
4211 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004212 else if (strcmp(args[3], "fqdn") == 0) {
4213 if (!*args[4]) {
Willy Tarreaua0752582017-11-05 10:17:49 +01004214 appctx->ctx.cli.severity = LOG_ERR;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004215 appctx->ctx.cli.msg = "set server <b>/<s> fqdn requires a FQDN.\n";
4216 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004217 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004218 }
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004219 warning = update_server_fqdn(sv, args[4], "stats socket command", 0);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004220 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004221 appctx->ctx.cli.severity = LOG_WARNING;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004222 appctx->ctx.cli.msg = warning;
4223 appctx->st0 = CLI_ST_PRINT;
4224 }
4225 }
William Lallemand222baf22016-11-19 02:00:33 +01004226 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004227 appctx->ctx.cli.severity = LOG_ERR;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004228 appctx->ctx.cli.msg = "'set server <srv>' only supports 'agent', 'health', 'state', 'weight', 'addr', 'fqdn' and 'check-port'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004229 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004230 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004231 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004232 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004233 return 1;
4234}
4235
William Lallemand6b160942016-11-22 12:34:35 +01004236static int cli_parse_get_weight(char **args, struct appctx *appctx, void *private)
4237{
4238 struct stream_interface *si = appctx->owner;
4239 struct proxy *px;
4240 struct server *sv;
4241 char *line;
4242
4243
4244 /* split "backend/server" and make <line> point to server */
4245 for (line = args[2]; *line; line++)
4246 if (*line == '/') {
4247 *line++ = '\0';
4248 break;
4249 }
4250
4251 if (!*line) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004252 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand6b160942016-11-22 12:34:35 +01004253 appctx->ctx.cli.msg = "Require 'backend/server'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004254 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004255 return 1;
4256 }
4257
4258 if (!get_backend_server(args[2], line, &px, &sv)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004259 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand6b160942016-11-22 12:34:35 +01004260 appctx->ctx.cli.msg = px ? "No such server.\n" : "No such backend.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004261 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004262 return 1;
4263 }
4264
4265 /* return server's effective weight at the moment */
4266 snprintf(trash.str, trash.size, "%d (initial %d)\n", sv->uweight, sv->iweight);
Willy Tarreau06d80a92017-10-19 14:32:15 +02004267 if (ci_putstr(si_ic(si), trash.str) == -1) {
William Lallemand6b160942016-11-22 12:34:35 +01004268 si_applet_cant_put(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004269 return 0;
4270 }
William Lallemand6b160942016-11-22 12:34:35 +01004271 return 1;
4272}
4273
4274static int cli_parse_set_weight(char **args, struct appctx *appctx, void *private)
4275{
4276 struct server *sv;
4277 const char *warning;
4278
4279 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4280 return 1;
4281
4282 sv = cli_find_server(appctx, args[2]);
4283 if (!sv)
4284 return 1;
4285
4286 warning = server_parse_weight_change_request(sv, args[3]);
4287 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004288 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand6b160942016-11-22 12:34:35 +01004289 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004290 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004291 }
4292 return 1;
4293}
4294
Willy Tarreaub8026272016-11-23 11:26:56 +01004295/* parse a "set maxconn server" command. It always returns 1. */
4296static int cli_parse_set_maxconn_server(char **args, struct appctx *appctx, void *private)
4297{
4298 struct server *sv;
4299 const char *warning;
4300
4301 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4302 return 1;
4303
4304 sv = cli_find_server(appctx, args[3]);
4305 if (!sv)
4306 return 1;
4307
4308 warning = server_parse_maxconn_change_request(sv, args[4]);
4309 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004310 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreaub8026272016-11-23 11:26:56 +01004311 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004312 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaub8026272016-11-23 11:26:56 +01004313 }
4314 return 1;
4315}
William Lallemand6b160942016-11-22 12:34:35 +01004316
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004317/* parse a "disable agent" command. It always returns 1. */
4318static int cli_parse_disable_agent(char **args, struct appctx *appctx, void *private)
4319{
4320 struct server *sv;
4321
4322 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4323 return 1;
4324
4325 sv = cli_find_server(appctx, args[2]);
4326 if (!sv)
4327 return 1;
4328
4329 sv->agent.state &= ~CHK_ST_ENABLED;
4330 return 1;
4331}
4332
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004333/* parse a "disable health" command. It always returns 1. */
4334static int cli_parse_disable_health(char **args, struct appctx *appctx, void *private)
4335{
4336 struct server *sv;
4337
4338 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4339 return 1;
4340
4341 sv = cli_find_server(appctx, args[2]);
4342 if (!sv)
4343 return 1;
4344
4345 sv->check.state &= ~CHK_ST_ENABLED;
4346 return 1;
4347}
4348
Willy Tarreauffb4d582016-11-24 12:47:00 +01004349/* parse a "disable server" command. It always returns 1. */
4350static int cli_parse_disable_server(char **args, struct appctx *appctx, void *private)
4351{
4352 struct server *sv;
4353
4354 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4355 return 1;
4356
4357 sv = cli_find_server(appctx, args[2]);
4358 if (!sv)
4359 return 1;
4360
4361 srv_adm_set_maint(sv);
4362 return 1;
4363}
4364
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004365/* parse a "enable agent" command. It always returns 1. */
4366static int cli_parse_enable_agent(char **args, struct appctx *appctx, void *private)
4367{
4368 struct server *sv;
4369
4370 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4371 return 1;
4372
4373 sv = cli_find_server(appctx, args[2]);
4374 if (!sv)
4375 return 1;
4376
4377 if (!(sv->agent.state & CHK_ST_CONFIGURED)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004378 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004379 appctx->ctx.cli.msg = "Agent was not configured on this server, cannot enable.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004380 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004381 return 1;
4382 }
4383
4384 sv->agent.state |= CHK_ST_ENABLED;
4385 return 1;
4386}
4387
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004388/* parse a "enable health" command. It always returns 1. */
4389static int cli_parse_enable_health(char **args, struct appctx *appctx, void *private)
4390{
4391 struct server *sv;
4392
4393 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4394 return 1;
4395
4396 sv = cli_find_server(appctx, args[2]);
4397 if (!sv)
4398 return 1;
4399
4400 sv->check.state |= CHK_ST_ENABLED;
4401 return 1;
4402}
4403
Willy Tarreauffb4d582016-11-24 12:47:00 +01004404/* parse a "enable server" command. It always returns 1. */
4405static int cli_parse_enable_server(char **args, struct appctx *appctx, void *private)
4406{
4407 struct server *sv;
4408
4409 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4410 return 1;
4411
4412 sv = cli_find_server(appctx, args[2]);
4413 if (!sv)
4414 return 1;
4415
4416 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004417 if (!(sv->flags & SRV_F_COOKIESET)
4418 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4419 sv->cookie)
4420 srv_check_for_dup_dyncookie(sv);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004421 return 1;
4422}
4423
William Lallemand222baf22016-11-19 02:00:33 +01004424/* register cli keywords */
4425static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004426 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004427 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004428 { { "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 +01004429 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004430 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004431 { { "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 +01004432 { { "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 +01004433 { { "set", "server", NULL }, "set server : change a server's state, weight or address", cli_parse_set_server },
William Lallemand6b160942016-11-22 12:34:35 +01004434 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4435 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4436
William Lallemand222baf22016-11-19 02:00:33 +01004437 {{},}
4438}};
4439
4440__attribute__((constructor))
4441static void __server_init(void)
4442{
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004443 HA_SPIN_INIT(&updated_servers_lock);
William Lallemand222baf22016-11-19 02:00:33 +01004444 cli_register_kw(&cli_kws);
4445}
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004446
Emeric Brun64cc49c2017-10-03 14:46:45 +02004447/*
4448 * This function applies server's status changes, it is
4449 * is designed to be called asynchronously.
4450 *
4451 */
4452void srv_update_status(struct server *s)
4453{
4454 struct check *check = &s->check;
4455 int xferred;
4456 struct proxy *px = s->proxy;
4457 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4458 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4459 int log_level;
4460 struct chunk *tmptrash = NULL;
4461
4462
4463 /* If currently main is not set we try to apply pending state changes */
4464 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4465 int next_admin;
4466
4467 /* Backup next admin */
4468 next_admin = s->next_admin;
4469
4470 /* restore current admin state */
4471 s->next_admin = s->cur_admin;
4472
4473 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4474 s->last_change = now.tv_sec;
4475 if (s->proxy->lbprm.set_server_status_down)
4476 s->proxy->lbprm.set_server_status_down(s);
4477
4478 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4479 srv_shutdown_streams(s, SF_ERR_DOWN);
4480
4481 /* we might have streams queued on this server and waiting for
4482 * a connection. Those which are redispatchable will be queued
4483 * to another server or to the proxy itself.
4484 */
4485 xferred = pendconn_redistribute(s);
4486
4487 tmptrash = alloc_trash_chunk();
4488 if (tmptrash) {
4489 chunk_printf(tmptrash,
4490 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4491 s->proxy->id, s->id);
4492
Emeric Brun5a133512017-10-19 14:42:30 +02004493 srv_append_status(tmptrash, s, NULL, xferred, 0);
Christopher Faulet767a84b2017-11-24 16:50:31 +01004494 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004495
4496 /* we don't send an alert if the server was previously paused */
4497 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
4498 send_log(s->proxy, log_level, "%s.\n", tmptrash->str);
4499 send_email_alert(s, log_level, "%s", tmptrash->str);
4500 free_trash_chunk(tmptrash);
4501 tmptrash = NULL;
4502 }
4503 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4504 set_backend_down(s->proxy);
4505
4506 s->counters.down_trans++;
4507 }
4508 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4509 s->last_change = now.tv_sec;
4510 if (s->proxy->lbprm.set_server_status_down)
4511 s->proxy->lbprm.set_server_status_down(s);
4512
4513 /* we might have streams queued on this server and waiting for
4514 * a connection. Those which are redispatchable will be queued
4515 * to another server or to the proxy itself.
4516 */
4517 xferred = pendconn_redistribute(s);
4518
4519 tmptrash = alloc_trash_chunk();
4520 if (tmptrash) {
4521 chunk_printf(tmptrash,
4522 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4523 s->proxy->id, s->id);
4524
Emeric Brun5a133512017-10-19 14:42:30 +02004525 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004526
Christopher Faulet767a84b2017-11-24 16:50:31 +01004527 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004528 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4529 free_trash_chunk(tmptrash);
4530 tmptrash = NULL;
4531 }
4532
4533 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4534 set_backend_down(s->proxy);
4535 }
4536 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4537 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4538 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4539 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4540 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4541 s->proxy->last_change = now.tv_sec;
4542 }
4543
4544 if (s->next_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
4545 s->down_time += now.tv_sec - s->last_change;
4546
4547 s->last_change = now.tv_sec;
4548 if (s->next_state == SRV_ST_STARTING)
4549 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4550
4551 server_recalc_eweight(s);
4552 /* now propagate the status change to any LB algorithms */
4553 if (px->lbprm.update_server_eweight)
4554 px->lbprm.update_server_eweight(s);
4555 else if (srv_willbe_usable(s)) {
4556 if (px->lbprm.set_server_status_up)
4557 px->lbprm.set_server_status_up(s);
4558 }
4559 else {
4560 if (px->lbprm.set_server_status_down)
4561 px->lbprm.set_server_status_down(s);
4562 }
4563
4564 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4565 * and it's not a backup server and its effective weight is > 0,
4566 * then it can accept new connections, so we shut down all streams
4567 * on all backup servers.
4568 */
4569 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4570 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4571 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4572
4573 /* check if we can handle some connections queued at the proxy. We
4574 * will take as many as we can handle.
4575 */
4576 xferred = pendconn_grab_from_px(s);
4577
4578 tmptrash = alloc_trash_chunk();
4579 if (tmptrash) {
4580 chunk_printf(tmptrash,
4581 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4582 s->proxy->id, s->id);
4583
Emeric Brun5a133512017-10-19 14:42:30 +02004584 srv_append_status(tmptrash, s, NULL, xferred, 0);
Christopher Faulet767a84b2017-11-24 16:50:31 +01004585 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004586 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4587 send_email_alert(s, LOG_NOTICE, "%s", tmptrash->str);
4588 free_trash_chunk(tmptrash);
4589 tmptrash = NULL;
4590 }
4591
4592 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4593 set_backend_down(s->proxy);
4594 }
4595 else if (s->cur_eweight != s->next_eweight) {
4596 /* now propagate the status change to any LB algorithms */
4597 if (px->lbprm.update_server_eweight)
4598 px->lbprm.update_server_eweight(s);
4599 else if (srv_willbe_usable(s)) {
4600 if (px->lbprm.set_server_status_up)
4601 px->lbprm.set_server_status_up(s);
4602 }
4603 else {
4604 if (px->lbprm.set_server_status_down)
4605 px->lbprm.set_server_status_down(s);
4606 }
4607
4608 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4609 set_backend_down(s->proxy);
4610 }
4611
4612 s->next_admin = next_admin;
4613 }
4614
Emeric Brun5a133512017-10-19 14:42:30 +02004615 /* reset operational state change */
4616 *s->op_st_chg.reason = 0;
4617 s->op_st_chg.status = s->op_st_chg.code = -1;
4618 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004619
4620 /* Now we try to apply pending admin changes */
4621
4622 /* Maintenance must also disable health checks */
4623 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4624 if (s->check.state & CHK_ST_ENABLED) {
4625 s->check.state |= CHK_ST_PAUSED;
4626 check->health = 0;
4627 }
4628
4629 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004630 tmptrash = alloc_trash_chunk();
4631 if (tmptrash) {
4632 chunk_printf(tmptrash,
4633 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4634 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4635 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004636
Olivier Houchard796a2b32017-10-24 17:42:47 +02004637 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004638
Olivier Houchard796a2b32017-10-24 17:42:47 +02004639 if (!(global.mode & MODE_STARTING)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004640 ha_warning("%s.\n", tmptrash->str);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004641 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4642 }
4643 free_trash_chunk(tmptrash);
4644 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004645 }
Emeric Brun8f298292017-12-06 16:47:17 +01004646 /* commit new admin status */
4647
4648 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004649 }
4650 else { /* server was still running */
4651 check->health = 0; /* failure */
4652 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004653
4654 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004655 if (s->proxy->lbprm.set_server_status_down)
4656 s->proxy->lbprm.set_server_status_down(s);
4657
Emeric Brun64cc49c2017-10-03 14:46:45 +02004658 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4659 srv_shutdown_streams(s, SF_ERR_DOWN);
4660
4661 /* we might have streams queued on this server and waiting for
4662 * a connection. Those which are redispatchable will be queued
4663 * to another server or to the proxy itself.
4664 */
4665 xferred = pendconn_redistribute(s);
4666
4667 tmptrash = alloc_trash_chunk();
4668 if (tmptrash) {
4669 chunk_printf(tmptrash,
4670 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
4671 s->flags & SRV_F_BACKUP ? "Backup " : "",
4672 s->proxy->id, s->id,
4673 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4674
4675 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
4676
4677 if (!(global.mode & MODE_STARTING)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004678 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004679 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n", tmptrash->str);
4680 }
4681 free_trash_chunk(tmptrash);
4682 tmptrash = NULL;
4683 }
4684 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4685 set_backend_down(s->proxy);
4686
4687 s->counters.down_trans++;
4688 }
4689 }
4690 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
4691 /* OK here we're leaving maintenance, we have many things to check,
4692 * because the server might possibly be coming back up depending on
4693 * its state. In practice, leaving maintenance means that we should
4694 * immediately turn to UP (more or less the slowstart) under the
4695 * following conditions :
4696 * - server is neither checked nor tracked
4697 * - server tracks another server which is not checked
4698 * - server tracks another server which is already up
4699 * Which sums up as something simpler :
4700 * "either the tracking server is up or the server's checks are disabled
4701 * or up". Otherwise we only re-enable health checks. There's a special
4702 * case associated to the stopping state which can be inherited. Note
4703 * that the server might still be in drain mode, which is naturally dealt
4704 * with by the lower level functions.
4705 */
4706
4707 if (s->check.state & CHK_ST_ENABLED) {
4708 s->check.state &= ~CHK_ST_PAUSED;
4709 check->health = check->rise; /* start OK but check immediately */
4710 }
4711
4712 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
4713 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
4714 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
4715 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
4716 s->next_state = SRV_ST_STOPPING;
4717 }
4718 else {
4719 s->next_state = SRV_ST_STARTING;
4720 if (s->slowstart > 0)
4721 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4722 else
4723 s->next_state = SRV_ST_RUNNING;
4724 }
4725
4726 }
4727
4728 tmptrash = alloc_trash_chunk();
4729 if (tmptrash) {
4730 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4731 chunk_printf(tmptrash,
4732 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
4733 s->flags & SRV_F_BACKUP ? "Backup " : "",
4734 s->proxy->id, s->id,
4735 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4736 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4737 }
4738 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4739 chunk_printf(tmptrash,
4740 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
4741 s->flags & SRV_F_BACKUP ? "Backup " : "",
4742 s->proxy->id, s->id, s->hostname,
4743 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4744 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4745 }
4746 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4747 chunk_printf(tmptrash,
4748 "%sServer %s/%s is %s/%s (leaving maintenance)",
4749 s->flags & SRV_F_BACKUP ? "Backup " : "",
4750 s->proxy->id, s->id,
4751 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4752 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4753 }
Christopher Faulet767a84b2017-11-24 16:50:31 +01004754 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004755 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4756 free_trash_chunk(tmptrash);
4757 tmptrash = NULL;
4758 }
4759
4760 server_recalc_eweight(s);
4761 /* now propagate the status change to any LB algorithms */
4762 if (px->lbprm.update_server_eweight)
4763 px->lbprm.update_server_eweight(s);
4764 else if (srv_willbe_usable(s)) {
4765 if (px->lbprm.set_server_status_up)
4766 px->lbprm.set_server_status_up(s);
4767 }
4768 else {
4769 if (px->lbprm.set_server_status_down)
4770 px->lbprm.set_server_status_down(s);
4771 }
4772
4773 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4774 set_backend_down(s->proxy);
4775
4776 }
4777 else if (s->next_admin & SRV_ADMF_MAINT) {
4778 /* remaining in maintenance mode, let's inform precisely about the
4779 * situation.
4780 */
4781 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4782 tmptrash = alloc_trash_chunk();
4783 if (tmptrash) {
4784 chunk_printf(tmptrash,
4785 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
4786 s->flags & SRV_F_BACKUP ? "Backup " : "",
4787 s->proxy->id, s->id);
4788
4789 if (s->track) /* normally it's mandatory here */
4790 chunk_appendf(tmptrash, " via %s/%s",
4791 s->track->proxy->id, s->track->id);
Christopher Faulet767a84b2017-11-24 16:50:31 +01004792 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004793 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4794 free_trash_chunk(tmptrash);
4795 tmptrash = NULL;
4796 }
4797 }
4798 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4799 tmptrash = alloc_trash_chunk();
4800 if (tmptrash) {
4801 chunk_printf(tmptrash,
4802 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
4803 s->flags & SRV_F_BACKUP ? "Backup " : "",
4804 s->proxy->id, s->id, s->hostname);
4805
4806 if (s->track) /* normally it's mandatory here */
4807 chunk_appendf(tmptrash, " via %s/%s",
4808 s->track->proxy->id, s->track->id);
Christopher Faulet767a84b2017-11-24 16:50:31 +01004809 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004810 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4811 free_trash_chunk(tmptrash);
4812 tmptrash = NULL;
4813 }
4814 }
4815 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4816 tmptrash = alloc_trash_chunk();
4817 if (tmptrash) {
4818 chunk_printf(tmptrash,
4819 "%sServer %s/%s remains in forced maintenance",
4820 s->flags & SRV_F_BACKUP ? "Backup " : "",
4821 s->proxy->id, s->id);
Christopher Faulet767a84b2017-11-24 16:50:31 +01004822 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004823 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4824 free_trash_chunk(tmptrash);
4825 tmptrash = NULL;
4826 }
4827 }
4828 /* don't report anything when leaving drain mode and remaining in maintenance */
4829
4830 s->cur_admin = s->next_admin;
4831 }
4832
4833 if (!(s->next_admin & SRV_ADMF_MAINT)) {
4834 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
4835 /* drain state is applied only if not yet in maint */
4836
4837 s->last_change = now.tv_sec;
4838 if (px->lbprm.set_server_status_down)
4839 px->lbprm.set_server_status_down(s);
4840
4841 /* we might have streams queued on this server and waiting for
4842 * a connection. Those which are redispatchable will be queued
4843 * to another server or to the proxy itself.
4844 */
4845 xferred = pendconn_redistribute(s);
4846
4847 tmptrash = alloc_trash_chunk();
4848 if (tmptrash) {
4849 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
4850 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4851 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4852
4853 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
4854
4855 if (!(global.mode & MODE_STARTING)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004856 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004857 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4858 send_email_alert(s, LOG_NOTICE, "%s", tmptrash->str);
4859 }
4860 free_trash_chunk(tmptrash);
4861 tmptrash = NULL;
4862 }
4863
4864 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4865 set_backend_down(s->proxy);
4866 }
4867 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
4868 /* OK completely leaving drain mode */
4869 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4870 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4871 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4872 s->proxy->last_change = now.tv_sec;
4873 }
4874
4875 if (s->last_change < now.tv_sec) // ignore negative times
4876 s->down_time += now.tv_sec - s->last_change;
4877 s->last_change = now.tv_sec;
4878 server_recalc_eweight(s);
4879
4880 tmptrash = alloc_trash_chunk();
4881 if (tmptrash) {
4882 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
4883 chunk_printf(tmptrash,
4884 "%sServer %s/%s is %s (leaving forced drain)",
4885 s->flags & SRV_F_BACKUP ? "Backup " : "",
4886 s->proxy->id, s->id,
4887 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
4888 }
4889 else {
4890 chunk_printf(tmptrash,
4891 "%sServer %s/%s is %s (leaving drain)",
4892 s->flags & SRV_F_BACKUP ? "Backup " : "",
4893 s->proxy->id, s->id,
4894 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
4895 if (s->track) /* normally it's mandatory here */
4896 chunk_appendf(tmptrash, " via %s/%s",
4897 s->track->proxy->id, s->track->id);
4898 }
4899
Christopher Faulet767a84b2017-11-24 16:50:31 +01004900 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004901 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4902 free_trash_chunk(tmptrash);
4903 tmptrash = NULL;
4904 }
4905
4906 /* now propagate the status change to any LB algorithms */
4907 if (px->lbprm.update_server_eweight)
4908 px->lbprm.update_server_eweight(s);
4909 else if (srv_willbe_usable(s)) {
4910 if (px->lbprm.set_server_status_up)
4911 px->lbprm.set_server_status_up(s);
4912 }
4913 else {
4914 if (px->lbprm.set_server_status_down)
4915 px->lbprm.set_server_status_down(s);
4916 }
4917 }
4918 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
4919 /* remaining in drain mode after removing one of its flags */
4920
4921 tmptrash = alloc_trash_chunk();
4922 if (tmptrash) {
4923 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
4924 chunk_printf(tmptrash,
4925 "%sServer %s/%s is leaving forced drain but remains in drain mode",
4926 s->flags & SRV_F_BACKUP ? "Backup " : "",
4927 s->proxy->id, s->id);
4928
4929 if (s->track) /* normally it's mandatory here */
4930 chunk_appendf(tmptrash, " via %s/%s",
4931 s->track->proxy->id, s->track->id);
4932 }
4933 else {
4934 chunk_printf(tmptrash,
4935 "%sServer %s/%s remains in forced drain mode",
4936 s->flags & SRV_F_BACKUP ? "Backup " : "",
4937 s->proxy->id, s->id);
4938 }
Christopher Faulet767a84b2017-11-24 16:50:31 +01004939 ha_warning("%s.\n", tmptrash->str);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004940 send_log(s->proxy, LOG_NOTICE, "%s.\n", tmptrash->str);
4941 free_trash_chunk(tmptrash);
4942 tmptrash = NULL;
4943 }
4944
4945 /* commit new admin status */
4946
4947 s->cur_admin = s->next_admin;
4948 }
4949 }
4950
4951 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02004952 *s->adm_st_chg_cause = 0;
4953}
4954/*
4955 * This function loops on servers registered for asynchronous
4956 * status changes
Christopher Faulet5d42e092017-10-16 12:00:40 +02004957 *
4958 * NOTE: No needs to lock <updated_servers> list because it is called inside the
4959 * sync point.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004960 */
4961void servers_update_status(void) {
4962 struct server *s, *stmp;
4963
4964 list_for_each_entry_safe(s, stmp, &updated_servers, update_status) {
4965 srv_update_status(s);
4966 LIST_DEL(&s->update_status);
4967 LIST_INIT(&s->update_status);
4968 }
4969}
4970
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004971/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004972 * Local variables:
4973 * c-indent-level: 8
4974 * c-basic-offset: 8
4975 * End:
4976 */