blob: 008bafa536d3dca2901bc5e89e2cb4600b4529cb [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
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020047static void srv_update_state(struct server *srv, int version, char **params);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010048static int srv_apply_lastaddr(struct server *srv, int *err_code);
Frédéric Lécailleb418c122017-04-26 11:24:02 +020049static int srv_set_fqdn(struct server *srv, const char *fqdn);
Willy Tarreaubaaee002006-06-26 02:48:02 +020050
Willy Tarreau21faa912012-10-10 08:27:36 +020051/* List head of all known server keywords */
52static struct srv_kw_list srv_keywords = {
53 .list = LIST_HEAD_INIT(srv_keywords.list)
54};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020055
Simon Hormana3608442013-11-01 16:46:15 +090056int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020057{
Willy Tarreau892337c2014-05-13 23:41:20 +020058 if ((s->state != SRV_ST_STOPPED) && s->last_change < now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020059 return s->down_time;
60
61 return now.tv_sec - s->last_change + s->down_time;
62}
Willy Tarreaubaaee002006-06-26 02:48:02 +020063
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050064int srv_lastsession(const struct server *s)
65{
66 if (s->counters.last_sess)
67 return now.tv_sec - s->counters.last_sess;
68
69 return -1;
70}
71
Simon Horman4a741432013-02-23 15:35:38 +090072int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020073{
Simon Horman4a741432013-02-23 15:35:38 +090074 const struct server *s = check->server;
75
Willy Tarreauff5ae352013-12-11 20:36:34 +010076 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090077 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010078
Willy Tarreau892337c2014-05-13 23:41:20 +020079 if ((s->state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +090080 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010081
Simon Horman4a741432013-02-23 15:35:38 +090082 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010083}
84
Olivier Houchard4e694042017-03-14 20:01:29 +010085void srv_set_dyncookie(struct server *s)
86{
87 struct proxy *p = s->proxy;
88 struct server *tmpserv;
89 char *tmpbuf;
90 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +010091 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +010092 size_t buffer_len;
93 int addr_len;
94 int port;
95
96 if ((s->flags & SRV_F_COOKIESET) ||
97 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
98 s->proxy->dyncookie_key == NULL)
99 return;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100100 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100101
102 if (s->addr.ss_family != AF_INET &&
103 s->addr.ss_family != AF_INET6)
104 return;
105 /*
106 * Buffer to calculate the cookie value.
107 * The buffer contains the secret key + the server IP address
108 * + the TCP port.
109 */
110 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
111 /*
112 * The TCP port should use only 2 bytes, but is stored in
113 * an unsigned int in struct server, so let's use 4, to be
114 * on the safe side.
115 */
116 buffer_len = key_len + addr_len + 4;
117 tmpbuf = trash.str;
118 memcpy(tmpbuf, p->dyncookie_key, key_len);
119 memcpy(&(tmpbuf[key_len]),
120 s->addr.ss_family == AF_INET ?
121 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
122 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
123 addr_len);
124 /*
125 * Make sure it's the same across all the load balancers,
126 * no matter their endianness.
127 */
128 port = htonl(s->svc_port);
129 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
130 hash_value = XXH64(tmpbuf, buffer_len, 0);
131 memprintf(&s->cookie, "%016llx", hash_value);
132 if (!s->cookie)
133 return;
134 s->cklen = 16;
135 /*
136 * Check that we did not get a hash collision.
137 * Unlikely, but it can happen.
138 */
Olivier Houchardb4a2d5e2017-04-04 22:10:36 +0200139 for (tmpserv = p->srv; tmpserv != NULL;
140 tmpserv = tmpserv->next) {
141 if (tmpserv == s)
142 continue;
143 if (tmpserv->cookie &&
144 strcmp(tmpserv->cookie, s->cookie) == 0) {
145 Warning("We generated two equal cookies for two different servers.\n"
146 "Please change the secret key for '%s'.\n",
147 s->proxy->id);
Olivier Houchard4e694042017-03-14 20:01:29 +0100148 }
Olivier Houchardb4a2d5e2017-04-04 22:10:36 +0200149 }
Olivier Houchard4e694042017-03-14 20:01:29 +0100150}
151
Willy Tarreau21faa912012-10-10 08:27:36 +0200152/*
153 * Registers the server keyword list <kwl> as a list of valid keywords for next
154 * parsing sessions.
155 */
156void srv_register_keywords(struct srv_kw_list *kwl)
157{
158 LIST_ADDQ(&srv_keywords.list, &kwl->list);
159}
160
161/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
162 * keyword is found with a NULL ->parse() function, then an attempt is made to
163 * find one with a valid ->parse() function. This way it is possible to declare
164 * platform-dependant, known keywords as NULL, then only declare them as valid
165 * if some options are met. Note that if the requested keyword contains an
166 * opening parenthesis, everything from this point is ignored.
167 */
168struct srv_kw *srv_find_kw(const char *kw)
169{
170 int index;
171 const char *kwend;
172 struct srv_kw_list *kwl;
173 struct srv_kw *ret = NULL;
174
175 kwend = strchr(kw, '(');
176 if (!kwend)
177 kwend = kw + strlen(kw);
178
179 list_for_each_entry(kwl, &srv_keywords.list, list) {
180 for (index = 0; kwl->kw[index].kw != NULL; index++) {
181 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
182 kwl->kw[index].kw[kwend-kw] == 0) {
183 if (kwl->kw[index].parse)
184 return &kwl->kw[index]; /* found it !*/
185 else
186 ret = &kwl->kw[index]; /* may be OK */
187 }
188 }
189 }
190 return ret;
191}
192
193/* Dumps all registered "server" keywords to the <out> string pointer. The
194 * unsupported keywords are only dumped if their supported form was not
195 * found.
196 */
197void srv_dump_kws(char **out)
198{
199 struct srv_kw_list *kwl;
200 int index;
201
202 *out = NULL;
203 list_for_each_entry(kwl, &srv_keywords.list, list) {
204 for (index = 0; kwl->kw[index].kw != NULL; index++) {
205 if (kwl->kw[index].parse ||
206 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
207 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
208 kwl->scope,
209 kwl->kw[index].kw,
210 kwl->kw[index].skip ? " <arg>" : "",
211 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
212 kwl->kw[index].parse ? "" : " (not supported)");
213 }
214 }
215 }
216}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100217
Frédéric Lécaille6e5e0d82017-03-20 16:30:18 +0100218/* Parse the "addr" server keyword */
219static int srv_parse_addr(char **args, int *cur_arg,
220 struct proxy *curproxy, struct server *newsrv, char **err)
221{
222 char *errmsg, *arg;
223 struct sockaddr_storage *sk;
224 int port1, port2;
225 struct protocol *proto;
226
227 errmsg = NULL;
228 arg = args[*cur_arg + 1];
229
230 if (!*arg) {
231 memprintf(err, "'%s' expects <ipv4|ipv6> as argument.\n", args[*cur_arg]);
232 goto err;
233 }
234
235 sk = str2sa_range(arg, NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
236 if (!sk) {
237 memprintf(err, "'%s' : %s", args[*cur_arg], errmsg);
238 goto err;
239 }
240
241 proto = protocol_by_family(sk->ss_family);
242 if (!proto || !proto->connect) {
243 memprintf(err, "'%s %s' : connect() not supported for this address family.\n",
244 args[*cur_arg], arg);
245 goto err;
246 }
247
248 if (port1 != port2) {
249 memprintf(err, "'%s' : port ranges and offsets are not allowed in '%s'\n",
250 args[*cur_arg], arg);
251 goto err;
252 }
253
254 newsrv->check.addr = newsrv->agent.addr = *sk;
255 newsrv->flags |= SRV_F_CHECKADDR;
256 newsrv->flags |= SRV_F_AGENTADDR;
257
258 return 0;
259
260 err:
261 free(errmsg);
262 return ERR_ALERT | ERR_FATAL;
263}
264
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +0100265/* Parse the "agent-check" server keyword */
266static int srv_parse_agent_check(char **args, int *cur_arg,
267 struct proxy *curproxy, struct server *newsrv, char **err)
268{
269 newsrv->do_agent = 1;
270 return 0;
271}
272
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100273/* Parse the "backup" server keyword */
274static int srv_parse_backup(char **args, int *cur_arg,
275 struct proxy *curproxy, struct server *newsrv, char **err)
276{
277 newsrv->flags |= SRV_F_BACKUP;
278 return 0;
279}
280
Frédéric Lécaille65aa3562017-03-14 11:20:13 +0100281/* Parse the "check" server keyword */
282static int srv_parse_check(char **args, int *cur_arg,
283 struct proxy *curproxy, struct server *newsrv, char **err)
284{
285 newsrv->do_check = 1;
286 return 0;
287}
288
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100289/* Parse the "check-send-proxy" server keyword */
290static int srv_parse_check_send_proxy(char **args, int *cur_arg,
291 struct proxy *curproxy, struct server *newsrv, char **err)
292{
293 newsrv->check.send_proxy = 1;
294 return 0;
295}
296
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100297/* Parse the "cookie" server keyword */
298static int srv_parse_cookie(char **args, int *cur_arg,
299 struct proxy *curproxy, struct server *newsrv, char **err)
300{
301 char *arg;
302
303 arg = args[*cur_arg + 1];
304 if (!*arg) {
305 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
306 return ERR_ALERT | ERR_FATAL;
307 }
308
309 free(newsrv->cookie);
310 newsrv->cookie = strdup(arg);
311 newsrv->cklen = strlen(arg);
312 newsrv->flags |= SRV_F_COOKIESET;
313 return 0;
314}
315
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100316/* Parse the "disabled" server keyword */
317static int srv_parse_disabled(char **args, int *cur_arg,
318 struct proxy *curproxy, struct server *newsrv, char **err)
319{
320 newsrv->admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
321 newsrv->state = SRV_ST_STOPPED;
322 newsrv->check.state |= CHK_ST_PAUSED;
323 newsrv->check.health = 0;
324 return 0;
325}
326
327/* Parse the "enabled" server keyword */
328static int srv_parse_enabled(char **args, int *cur_arg,
329 struct proxy *curproxy, struct server *newsrv, char **err)
330{
331 newsrv->admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
332 newsrv->state = SRV_ST_RUNNING;
333 newsrv->check.state &= ~CHK_ST_PAUSED;
334 newsrv->check.health = newsrv->check.rise;
335 return 0;
336}
337
Willy Tarreaudff55432012-10-10 17:51:05 +0200338/* parse the "id" server keyword */
339static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
340{
341 struct eb32_node *node;
342
343 if (!*args[*cur_arg + 1]) {
344 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
345 return ERR_ALERT | ERR_FATAL;
346 }
347
348 newsrv->puid = atol(args[*cur_arg + 1]);
349 newsrv->conf.id.key = newsrv->puid;
350
351 if (newsrv->puid <= 0) {
352 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
353 return ERR_ALERT | ERR_FATAL;
354 }
355
356 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
357 if (node) {
358 struct server *target = container_of(node, struct server, conf.id);
359 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
360 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
361 target->id);
362 return ERR_ALERT | ERR_FATAL;
363 }
364
365 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200366 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200367 return 0;
368}
369
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100370/* Parse the "namespace" server keyword */
371static int srv_parse_namespace(char **args, int *cur_arg,
372 struct proxy *curproxy, struct server *newsrv, char **err)
373{
374#ifdef CONFIG_HAP_NS
375 char *arg;
376
377 arg = args[*cur_arg + 1];
378 if (!*arg) {
379 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
380 return ERR_ALERT | ERR_FATAL;
381 }
382
383 if (!strcmp(arg, "*")) {
384 /* Use the namespace associated with the connection (if present). */
385 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
386 return 0;
387 }
388
389 /*
390 * As this parser may be called several times for the same 'default-server'
391 * object, or for a new 'server' instance deriving from a 'default-server'
392 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
393 */
394 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
395
396 newsrv->netns = netns_store_lookup(arg, strlen(arg));
397 if (!newsrv->netns)
398 newsrv->netns = netns_store_insert(arg);
399
400 if (!newsrv->netns) {
401 memprintf(err, "Cannot open namespace '%s'", arg);
402 return ERR_ALERT | ERR_FATAL;
403 }
404
405 return 0;
406#else
407 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
408 return ERR_ALERT | ERR_FATAL;
409#endif
410}
411
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +0100412/* Parse the "no-agent-check" server keyword */
413static int srv_parse_no_agent_check(char **args, int *cur_arg,
414 struct proxy *curproxy, struct server *newsrv, char **err)
415{
416 free_check(&newsrv->agent);
417 newsrv->agent.inter = 0;
418 newsrv->agent.port = 0;
419 newsrv->agent.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED & ~CHK_ST_AGENT;
420 newsrv->do_agent = 0;
421 return 0;
422}
423
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100424/* Parse the "no-backup" server keyword */
425static int srv_parse_no_backup(char **args, int *cur_arg,
426 struct proxy *curproxy, struct server *newsrv, char **err)
427{
428 newsrv->flags &= ~SRV_F_BACKUP;
429 return 0;
430}
431
Frédéric Lécaille65aa3562017-03-14 11:20:13 +0100432/* Parse the "no-check" server keyword */
433static int srv_parse_no_check(char **args, int *cur_arg,
434 struct proxy *curproxy, struct server *newsrv, char **err)
435{
436 free_check(&newsrv->check);
437 newsrv->check.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED;
438 newsrv->do_check = 0;
439 return 0;
440}
441
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100442/* Parse the "no-check-send-proxy" server keyword */
443static int srv_parse_no_check_send_proxy(char **args, int *cur_arg,
444 struct proxy *curproxy, struct server *newsrv, char **err)
445{
446 newsrv->check.send_proxy = 0;
447 return 0;
448}
449
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100450/* Disable server PROXY protocol flags. */
451static int inline srv_disable_pp_flags(struct server *srv, unsigned int flags)
452{
453 srv->pp_opts &= ~flags;
454 return 0;
455}
456
457/* Parse the "no-send-proxy" server keyword */
458static int srv_parse_no_send_proxy(char **args, int *cur_arg,
459 struct proxy *curproxy, struct server *newsrv, char **err)
460{
461 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
462}
463
464/* Parse the "no-send-proxy-v2" server keyword */
465static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
466 struct proxy *curproxy, struct server *newsrv, char **err)
467{
468 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
469}
470
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100471/* Parse the "non-stick" server keyword */
472static int srv_parse_non_stick(char **args, int *cur_arg,
473 struct proxy *curproxy, struct server *newsrv, char **err)
474{
475 newsrv->flags |= SRV_F_NON_STICK;
476 return 0;
477}
478
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100479/* Enable server PROXY protocol flags. */
480static int inline srv_enable_pp_flags(struct server *srv, unsigned int flags)
481{
482 srv->pp_opts |= flags;
483 return 0;
484}
485
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100486/* Parse the "observe" server keyword */
487static int srv_parse_observe(char **args, int *cur_arg,
488 struct proxy *curproxy, struct server *newsrv, char **err)
489{
490 char *arg;
491
492 arg = args[*cur_arg + 1];
493 if (!*arg) {
494 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
495 return ERR_ALERT | ERR_FATAL;
496 }
497
498 if (!strcmp(arg, "none")) {
499 newsrv->observe = HANA_OBS_NONE;
500 }
501 else if (!strcmp(arg, "layer4")) {
502 newsrv->observe = HANA_OBS_LAYER4;
503 }
504 else if (!strcmp(arg, "layer7")) {
505 if (curproxy->mode != PR_MODE_HTTP) {
506 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
507 return ERR_ALERT;
508 }
509 newsrv->observe = HANA_OBS_LAYER7;
510 }
511 else {
512 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
513 "but got '%s'\n", args[*cur_arg], arg);
514 return ERR_ALERT | ERR_FATAL;
515 }
516
517 return 0;
518}
519
Frédéric Lécaille16186232017-03-14 16:42:49 +0100520/* Parse the "redir" server keyword */
521static int srv_parse_redir(char **args, int *cur_arg,
522 struct proxy *curproxy, struct server *newsrv, char **err)
523{
524 char *arg;
525
526 arg = args[*cur_arg + 1];
527 if (!*arg) {
528 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
529 return ERR_ALERT | ERR_FATAL;
530 }
531
532 free(newsrv->rdr_pfx);
533 newsrv->rdr_pfx = strdup(arg);
534 newsrv->rdr_len = strlen(arg);
535
536 return 0;
537}
538
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100539/* Parse the "send-proxy" server keyword */
540static int srv_parse_send_proxy(char **args, int *cur_arg,
541 struct proxy *curproxy, struct server *newsrv, char **err)
542{
543 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
544}
545
546/* Parse the "send-proxy-v2" server keyword */
547static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
548 struct proxy *curproxy, struct server *newsrv, char **err)
549{
550 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
551}
552
Frédéric Lécailledba97072017-03-17 15:33:50 +0100553
554/* Parse the "source" server keyword */
555static int srv_parse_source(char **args, int *cur_arg,
556 struct proxy *curproxy, struct server *newsrv, char **err)
557{
558 char *errmsg;
559 int port_low, port_high;
560 struct sockaddr_storage *sk;
561 struct protocol *proto;
562
563 errmsg = NULL;
564
565 if (!*args[*cur_arg + 1]) {
566 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
567 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
568 goto err;
569 }
570
571 /* 'sk' is statically allocated (no need to be freed). */
572 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, &errmsg, NULL, NULL, 1);
573 if (!sk) {
574 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
575 goto err;
576 }
577
578 proto = protocol_by_family(sk->ss_family);
579 if (!proto || !proto->connect) {
580 Alert("'%s %s' : connect() not supported for this address family.\n",
581 args[*cur_arg], args[*cur_arg + 1]);
582 goto err;
583 }
584
585 newsrv->conn_src.opts |= CO_SRC_BIND;
586 newsrv->conn_src.source_addr = *sk;
587
588 if (port_low != port_high) {
589 int i;
590
591 if (!port_low || !port_high) {
592 Alert("'%s' does not support port offsets (found '%s').\n",
593 args[*cur_arg], args[*cur_arg + 1]);
594 goto err;
595 }
596
597 if (port_low <= 0 || port_low > 65535 ||
598 port_high <= 0 || port_high > 65535 ||
599 port_low > port_high) {
600 Alert("'%s': invalid source port range %d-%d.\n", args[*cur_arg], port_low, port_high);
601 goto err;
602 }
603 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
604 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
605 newsrv->conn_src.sport_range->ports[i] = port_low + i;
606 }
607
608 *cur_arg += 2;
609 while (*(args[*cur_arg])) {
610 if (!strcmp(args[*cur_arg], "usesrc")) { /* address to use outside */
611#if defined(CONFIG_HAP_TRANSPARENT)
612 if (!*args[*cur_arg + 1]) {
613 Alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
614 "or 'hdr_ip(name,#)' as argument.\n");
615 goto err;
616 }
617 if (!strcmp(args[*cur_arg + 1], "client")) {
618 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
619 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
620 }
621 else if (!strcmp(args[*cur_arg + 1], "clientip")) {
622 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
623 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
624 }
625 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
626 char *name, *end;
627
628 name = args[*cur_arg + 1] + 7;
629 while (isspace(*name))
630 name++;
631
632 end = name;
633 while (*end && !isspace(*end) && *end != ',' && *end != ')')
634 end++;
635
636 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
637 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
638 free(newsrv->conn_src.bind_hdr_name);
639 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
640 newsrv->conn_src.bind_hdr_len = end - name;
641 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
642 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
643 newsrv->conn_src.bind_hdr_occ = -1;
644
645 /* now look for an occurrence number */
646 while (isspace(*end))
647 end++;
648 if (*end == ',') {
649 end++;
650 name = end;
651 if (*end == '-')
652 end++;
653 while (isdigit((int)*end))
654 end++;
655 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
656 }
657
658 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
659 Alert("usesrc hdr_ip(name,num) does not support negative"
660 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
661 goto err;
662 }
663 }
664 else {
665 struct sockaddr_storage *sk;
666 int port1, port2;
667
668 /* 'sk' is statically allocated (no need to be freed). */
669 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
670 if (!sk) {
671 Alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
672 goto err;
673 }
674
675 proto = protocol_by_family(sk->ss_family);
676 if (!proto || !proto->connect) {
677 Alert("'%s %s' : connect() not supported for this address family.\n",
678 args[*cur_arg], args[*cur_arg + 1]);
679 goto err;
680 }
681
682 if (port1 != port2) {
683 Alert("'%s' : port ranges and offsets are not allowed in '%s'\n",
684 args[*cur_arg], args[*cur_arg + 1]);
685 goto err;
686 }
687 newsrv->conn_src.tproxy_addr = *sk;
688 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
689 }
690 global.last_checks |= LSTCHK_NETADM;
691 *cur_arg += 2;
692 continue;
693#else /* no TPROXY support */
694 Alert("'usesrc' not allowed here because support for TPROXY was not compiled in.\n");
695 goto err;
696#endif /* defined(CONFIG_HAP_TRANSPARENT) */
697 } /* "usesrc" */
698
699 if (!strcmp(args[*cur_arg], "interface")) { /* specifically bind to this interface */
700#ifdef SO_BINDTODEVICE
701 if (!*args[*cur_arg + 1]) {
702 Alert("'%s' : missing interface name.\n", args[0]);
703 goto err;
704 }
705 free(newsrv->conn_src.iface_name);
706 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
707 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
708 global.last_checks |= LSTCHK_NETADM;
709#else
710 Alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
711 goto err;
712#endif
713 *cur_arg += 2;
714 continue;
715 }
716 /* this keyword in not an option of "source" */
717 break;
718 } /* while */
719
720 return 0;
721
722 err:
723 free(errmsg);
724 return ERR_ALERT | ERR_FATAL;
725}
726
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100727/* Parse the "stick" server keyword */
728static int srv_parse_stick(char **args, int *cur_arg,
729 struct proxy *curproxy, struct server *newsrv, char **err)
730{
731 newsrv->flags &= ~SRV_F_NON_STICK;
732 return 0;
733}
734
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100735/* Parse the "track" server keyword */
736static int srv_parse_track(char **args, int *cur_arg,
737 struct proxy *curproxy, struct server *newsrv, char **err)
738{
739 char *arg;
740
741 arg = args[*cur_arg + 1];
742 if (!*arg) {
743 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
744 return ERR_ALERT | ERR_FATAL;
745 }
746
747 free(newsrv->trackit);
748 newsrv->trackit = strdup(arg);
749
750 return 0;
751}
752
Frédéric Lécailledba97072017-03-17 15:33:50 +0100753
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200754/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200755 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200756 * shutdown.
757 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200758void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200759{
Willy Tarreau87b09662015-04-03 00:22:06 +0200760 struct stream *stream, *stream_bck;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200761
Willy Tarreau87b09662015-04-03 00:22:06 +0200762 list_for_each_entry_safe(stream, stream_bck, &srv->actconns, by_srv)
763 if (stream->srv_conn == srv)
764 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200765}
766
767/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200768 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200769 * the reason for the shutdown.
770 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200771void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200772{
773 struct server *srv;
774
775 for (srv = px->srv; srv != NULL; srv = srv->next)
776 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200777 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200778}
779
Willy Tarreaubda92272014-05-20 21:55:30 +0200780/* Appends some information to a message string related to a server going UP or
781 * DOWN. If both <forced> and <reason> are null and the server tracks another
782 * one, a "via" information will be provided to know where the status came from.
783 * If <reason> is non-null, the entire string will be appended after a comma and
784 * a space (eg: to report some information from the check that changed the state).
Willy Tarreau87b09662015-04-03 00:22:06 +0200785 * If <xferred> is non-negative, some information about requeued streams are
Willy Tarreaubda92272014-05-20 21:55:30 +0200786 * provided.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200787 */
Willy Tarreaubda92272014-05-20 21:55:30 +0200788void srv_append_status(struct chunk *msg, struct server *s, const char *reason, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200789{
Willy Tarreaubda92272014-05-20 21:55:30 +0200790 if (reason)
791 chunk_appendf(msg, ", %s", reason);
792 else if (!forced && s->track)
793 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200794
795 if (xferred >= 0) {
796 if (s->state == SRV_ST_STOPPED)
797 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
798 " %d sessions active, %d requeued, %d remaining in queue",
799 s->proxy->srv_act, s->proxy->srv_bck,
800 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
801 s->cur_sess, xferred, s->nbpend);
802 else
803 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
804 " %d sessions requeued, %d total in queue",
805 s->proxy->srv_act, s->proxy->srv_bck,
806 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
807 xferred, s->nbpend);
808 }
809}
810
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200811/* Marks server <s> down, regardless of its checks' statuses, notifies by all
812 * available means, recounts the remaining servers on the proxy and transfers
Willy Tarreau87b09662015-04-03 00:22:06 +0200813 * queued streams whenever possible to other servers. It automatically
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200814 * recomputes the number of servers, but not the map. Maintenance servers are
815 * ignored. It reports <reason> if non-null as the reason for going down. Note
816 * that it makes use of the trash to build the log strings, so <reason> must
817 * not be placed there.
818 */
819void srv_set_stopped(struct server *s, const char *reason)
820{
821 struct server *srv;
822 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
823 int srv_was_stopping = (s->state == SRV_ST_STOPPING);
Simon Horman64e34162015-02-06 11:11:57 +0900824 int log_level;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200825 int xferred;
826
827 if ((s->admin & SRV_ADMF_MAINT) || s->state == SRV_ST_STOPPED)
828 return;
829
830 s->last_change = now.tv_sec;
831 s->state = SRV_ST_STOPPED;
832 if (s->proxy->lbprm.set_server_status_down)
833 s->proxy->lbprm.set_server_status_down(s);
834
835 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
Willy Tarreaue7dff022015-04-03 01:14:29 +0200836 srv_shutdown_streams(s, SF_ERR_DOWN);
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200837
Willy Tarreau87b09662015-04-03 00:22:06 +0200838 /* we might have streams queued on this server and waiting for
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200839 * a connection. Those which are redispatchable will be queued
840 * to another server or to the proxy itself.
841 */
842 xferred = pendconn_redistribute(s);
843
844 chunk_printf(&trash,
845 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
846 s->proxy->id, s->id);
847
848 srv_append_status(&trash, s, reason, xferred, 0);
849 Warning("%s.\n", trash.str);
850
851 /* we don't send an alert if the server was previously paused */
Simon Horman64e34162015-02-06 11:11:57 +0900852 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
853 send_log(s->proxy, log_level, "%s.\n", trash.str);
854 send_email_alert(s, log_level, "%s", trash.str);
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200855
856 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
857 set_backend_down(s->proxy);
858
859 s->counters.down_trans++;
860
861 for (srv = s->trackers; srv; srv = srv->tracknext)
862 srv_set_stopped(srv, NULL);
863}
864
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200865/* Marks server <s> up regardless of its checks' statuses and provided it isn't
866 * in maintenance. Notifies by all available means, recounts the remaining
867 * servers on the proxy and tries to grab requests from the proxy. It
868 * automatically recomputes the number of servers, but not the map. Maintenance
869 * servers are ignored. It reports <reason> if non-null as the reason for going
870 * up. Note that it makes use of the trash to build the log strings, so <reason>
871 * must not be placed there.
872 */
873void srv_set_running(struct server *s, const char *reason)
874{
875 struct server *srv;
876 int xferred;
877
878 if (s->admin & SRV_ADMF_MAINT)
879 return;
880
881 if (s->state == SRV_ST_STARTING || s->state == SRV_ST_RUNNING)
882 return;
883
884 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
885 if (s->proxy->last_change < now.tv_sec) // ignore negative times
886 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
887 s->proxy->last_change = now.tv_sec;
888 }
889
890 if (s->state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
891 s->down_time += now.tv_sec - s->last_change;
892
893 s->last_change = now.tv_sec;
894
895 s->state = SRV_ST_STARTING;
896 if (s->slowstart > 0)
897 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
898 else
899 s->state = SRV_ST_RUNNING;
900
901 server_recalc_eweight(s);
902
903 /* If the server is set with "on-marked-up shutdown-backup-sessions",
904 * and it's not a backup server and its effective weight is > 0,
Willy Tarreau87b09662015-04-03 00:22:06 +0200905 * then it can accept new connections, so we shut down all streams
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200906 * on all backup servers.
907 */
908 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
909 !(s->flags & SRV_F_BACKUP) && s->eweight)
Willy Tarreaue7dff022015-04-03 01:14:29 +0200910 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200911
912 /* check if we can handle some connections queued at the proxy. We
913 * will take as many as we can handle.
914 */
915 xferred = pendconn_grab_from_px(s);
916
917 chunk_printf(&trash,
918 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
919 s->proxy->id, s->id);
920
921 srv_append_status(&trash, s, reason, xferred, 0);
922 Warning("%s.\n", trash.str);
923 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
Simon Horman4cd477f2015-04-30 13:10:34 +0900924 send_email_alert(s, LOG_NOTICE, "%s", trash.str);
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200925
926 for (srv = s->trackers; srv; srv = srv->tracknext)
927 srv_set_running(srv, NULL);
928}
929
Willy Tarreau8eb77842014-05-21 13:54:57 +0200930/* Marks server <s> stopping regardless of its checks' statuses and provided it
931 * isn't in maintenance. Notifies by all available means, recounts the remaining
932 * servers on the proxy and tries to grab requests from the proxy. It
933 * automatically recomputes the number of servers, but not the map. Maintenance
934 * servers are ignored. It reports <reason> if non-null as the reason for going
935 * up. Note that it makes use of the trash to build the log strings, so <reason>
936 * must not be placed there.
937 */
938void srv_set_stopping(struct server *s, const char *reason)
939{
940 struct server *srv;
941 int xferred;
942
943 if (s->admin & SRV_ADMF_MAINT)
944 return;
945
946 if (s->state == SRV_ST_STOPPING)
947 return;
948
949 s->last_change = now.tv_sec;
950 s->state = SRV_ST_STOPPING;
951 if (s->proxy->lbprm.set_server_status_down)
952 s->proxy->lbprm.set_server_status_down(s);
953
Willy Tarreau87b09662015-04-03 00:22:06 +0200954 /* we might have streams queued on this server and waiting for
Willy Tarreau8eb77842014-05-21 13:54:57 +0200955 * a connection. Those which are redispatchable will be queued
956 * to another server or to the proxy itself.
957 */
958 xferred = pendconn_redistribute(s);
959
960 chunk_printf(&trash,
961 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
962 s->proxy->id, s->id);
963
964 srv_append_status(&trash, s, reason, xferred, 0);
965
966 Warning("%s.\n", trash.str);
967 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
968
969 if (!s->proxy->srv_bck && !s->proxy->srv_act)
970 set_backend_down(s->proxy);
971
972 for (srv = s->trackers; srv; srv = srv->tracknext)
973 srv_set_stopping(srv, NULL);
974}
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200975
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200976/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
977 * enforce either maint mode or drain mode. It is not allowed to set more than
978 * one flag at once. The equivalent "inherited" flag is propagated to all
979 * tracking servers. Maintenance mode disables health checks (but not agent
980 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +0100981 * is done. If <cause> is non-null, it will be displayed at the end of the log
982 * lines to justify the state change.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200983 */
Willy Tarreau8b428482016-11-07 15:53:43 +0100984void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200985{
986 struct check *check = &s->check;
987 struct server *srv;
988 int xferred;
989
990 if (!mode)
991 return;
992
993 /* stop going down as soon as we meet a server already in the same state */
994 if (s->admin & mode)
995 return;
996
997 s->admin |= mode;
998
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200999 /* stop going down if the equivalent flag was already present (forced or inherited) */
1000 if (((mode & SRV_ADMF_MAINT) && (s->admin & ~mode & SRV_ADMF_MAINT)) ||
1001 ((mode & SRV_ADMF_DRAIN) && (s->admin & ~mode & SRV_ADMF_DRAIN)))
1002 return;
1003
1004 /* Maintenance must also disable health checks */
1005 if (mode & SRV_ADMF_MAINT) {
1006 if (s->check.state & CHK_ST_ENABLED) {
1007 s->check.state |= CHK_ST_PAUSED;
1008 check->health = 0;
1009 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001010
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001011 if (s->state == SRV_ST_STOPPED) { /* server was already down */
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001012 chunk_printf(&trash,
Willy Tarreau8b428482016-11-07 15:53:43 +01001013 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
1014 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
1015 cause ? " (" : "", cause ? cause : "", cause ? ")" : "");
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001016
Willy Tarreaubda92272014-05-20 21:55:30 +02001017 srv_append_status(&trash, s, NULL, -1, (mode & SRV_ADMF_FMAINT));
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001018
Willy Tarreau6fb8dc12016-11-03 19:42:36 +01001019 if (!(global.mode & MODE_STARTING)) {
1020 Warning("%s.\n", trash.str);
1021 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
1022 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001023 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001024 else { /* server was still running */
1025 int srv_was_stopping = (s->state == SRV_ST_STOPPING) || (s->admin & SRV_ADMF_DRAIN);
1026 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
1027
1028 check->health = 0; /* failure */
1029 s->last_change = now.tv_sec;
1030 s->state = SRV_ST_STOPPED;
1031 if (s->proxy->lbprm.set_server_status_down)
1032 s->proxy->lbprm.set_server_status_down(s);
1033
1034 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
Willy Tarreaue7dff022015-04-03 01:14:29 +02001035 srv_shutdown_streams(s, SF_ERR_DOWN);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001036
Willy Tarreau87b09662015-04-03 00:22:06 +02001037 /* we might have streams queued on this server and waiting for
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001038 * a connection. Those which are redispatchable will be queued
1039 * to another server or to the proxy itself.
1040 */
1041 xferred = pendconn_redistribute(s);
1042
1043 chunk_printf(&trash,
Willy Tarreau8b428482016-11-07 15:53:43 +01001044 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001045 s->flags & SRV_F_BACKUP ? "Backup " : "",
Willy Tarreau8b428482016-11-07 15:53:43 +01001046 s->proxy->id, s->id,
1047 cause ? " (" : "", cause ? cause : "", cause ? ")" : "");
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001048
1049 srv_append_status(&trash, s, NULL, xferred, (mode & SRV_ADMF_FMAINT));
1050
Willy Tarreau6fb8dc12016-11-03 19:42:36 +01001051 if (!(global.mode & MODE_STARTING)) {
1052 Warning("%s.\n", trash.str);
1053 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n", trash.str);
1054 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001055
1056 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
1057 set_backend_down(s->proxy);
1058
1059 s->counters.down_trans++;
1060 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001061 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001062
1063 /* drain state is applied only if not yet in maint */
1064 if ((mode & SRV_ADMF_DRAIN) && !(s->admin & SRV_ADMF_MAINT)) {
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001065 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
1066
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001067 s->last_change = now.tv_sec;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001068 if (s->proxy->lbprm.set_server_status_down)
1069 s->proxy->lbprm.set_server_status_down(s);
1070
Willy Tarreau87b09662015-04-03 00:22:06 +02001071 /* we might have streams queued on this server and waiting for
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001072 * a connection. Those which are redispatchable will be queued
1073 * to another server or to the proxy itself.
1074 */
1075 xferred = pendconn_redistribute(s);
1076
Willy Tarreau8b428482016-11-07 15:53:43 +01001077 chunk_printf(&trash, "%sServer %s/%s enters drain state%s%s%s",
1078 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
1079 cause ? " (" : "", cause ? cause : "", cause ? ")" : "");
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001080
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001081 srv_append_status(&trash, s, NULL, xferred, (mode & SRV_ADMF_FDRAIN));
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001082
Willy Tarreau6fb8dc12016-11-03 19:42:36 +01001083 if (!(global.mode & MODE_STARTING)) {
1084 Warning("%s.\n", trash.str);
1085 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
1086 send_email_alert(s, LOG_NOTICE, "%s", trash.str);
1087 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001088 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
1089 set_backend_down(s->proxy);
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001090 }
1091
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001092 /* compute the inherited flag to propagate */
1093 if (mode & SRV_ADMF_MAINT)
1094 mode = SRV_ADMF_IMAINT;
1095 else if (mode & SRV_ADMF_DRAIN)
1096 mode = SRV_ADMF_IDRAIN;
1097
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001098 for (srv = s->trackers; srv; srv = srv->tracknext)
Willy Tarreau8b428482016-11-07 15:53:43 +01001099 srv_set_admin_flag(srv, mode, cause);
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001100}
1101
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001102/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1103 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1104 * than one flag at once. The equivalent "inherited" flag is propagated to all
1105 * tracking servers. Leaving maintenance mode re-enables health checks. When
1106 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001107 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001108void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001109{
1110 struct check *check = &s->check;
1111 struct server *srv;
1112 int xferred = -1;
1113
1114 if (!mode)
1115 return;
1116
1117 /* stop going down as soon as we see the flag is not there anymore */
1118 if (!(s->admin & mode))
1119 return;
1120
1121 s->admin &= ~mode;
1122
1123 if (s->admin & SRV_ADMF_MAINT) {
1124 /* remaining in maintenance mode, let's inform precisely about the
1125 * situation.
1126 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001127 if (mode & SRV_ADMF_FMAINT) {
1128 chunk_printf(&trash,
1129 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
1130 s->flags & SRV_F_BACKUP ? "Backup " : "",
1131 s->proxy->id, s->id);
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001132
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001133 if (s->track) /* normally it's mandatory here */
1134 chunk_appendf(&trash, " via %s/%s",
1135 s->track->proxy->id, s->track->id);
1136 Warning("%s.\n", trash.str);
1137 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
1138 }
Willy Tarreaue6599732016-11-07 15:42:33 +01001139 if (mode & SRV_ADMF_RMAINT) {
1140 chunk_printf(&trash,
1141 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
1142 s->flags & SRV_F_BACKUP ? "Backup " : "",
1143 s->proxy->id, s->id, s->hostname);
1144
1145 if (s->track) /* normally it's mandatory here */
1146 chunk_appendf(&trash, " via %s/%s",
1147 s->track->proxy->id, s->track->id);
1148 Warning("%s.\n", trash.str);
1149 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
1150 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001151 else if (mode & SRV_ADMF_IMAINT) {
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001152 chunk_printf(&trash,
1153 "%sServer %s/%s remains in forced maintenance",
1154 s->flags & SRV_F_BACKUP ? "Backup " : "",
1155 s->proxy->id, s->id);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001156 Warning("%s.\n", trash.str);
1157 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
1158 }
1159 /* don't report anything when leaving drain mode and remaining in maintenance */
1160 }
1161 else if (mode & SRV_ADMF_MAINT) {
1162 /* OK here we're leaving maintenance, we have many things to check,
1163 * because the server might possibly be coming back up depending on
1164 * its state. In practice, leaving maintenance means that we should
1165 * immediately turn to UP (more or less the slowstart) under the
1166 * following conditions :
1167 * - server is neither checked nor tracked
1168 * - server tracks another server which is not checked
1169 * - server tracks another server which is already up
1170 * Which sums up as something simpler :
1171 * "either the tracking server is up or the server's checks are disabled
1172 * or up". Otherwise we only re-enable health checks. There's a special
1173 * case associated to the stopping state which can be inherited. Note
1174 * that the server might still be in drain mode, which is naturally dealt
1175 * with by the lower level functions.
1176 */
1177
1178 if (s->check.state & CHK_ST_ENABLED) {
1179 s->check.state &= ~CHK_ST_PAUSED;
1180 check->health = check->rise; /* start OK but check immediately */
1181 }
1182
1183 if ((!s->track || s->track->state != SRV_ST_STOPPED) &&
1184 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
1185 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
1186 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
1187 if (s->proxy->last_change < now.tv_sec) // ignore negative times
1188 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
1189 s->proxy->last_change = now.tv_sec;
1190 }
1191
1192 if (s->last_change < now.tv_sec) // ignore negative times
1193 s->down_time += now.tv_sec - s->last_change;
1194 s->last_change = now.tv_sec;
1195
1196 if (s->track && s->track->state == SRV_ST_STOPPING)
1197 s->state = SRV_ST_STOPPING;
1198 else {
1199 s->state = SRV_ST_STARTING;
1200 if (s->slowstart > 0)
1201 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
1202 else
1203 s->state = SRV_ST_RUNNING;
1204 }
1205
1206 server_recalc_eweight(s);
1207
1208 /* If the server is set with "on-marked-up shutdown-backup-sessions",
1209 * and it's not a backup server and its effective weight is > 0,
Willy Tarreau87b09662015-04-03 00:22:06 +02001210 * then it can accept new connections, so we shut down all streams
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001211 * on all backup servers.
1212 */
1213 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
1214 !(s->flags & SRV_F_BACKUP) && s->eweight)
Willy Tarreaue7dff022015-04-03 01:14:29 +02001215 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001216
1217 /* check if we can handle some connections queued at the proxy. We
1218 * will take as many as we can handle.
1219 */
1220 xferred = pendconn_grab_from_px(s);
1221 }
1222
1223 if (mode & SRV_ADMF_FMAINT) {
1224 chunk_printf(&trash,
1225 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
1226 s->flags & SRV_F_BACKUP ? "Backup " : "",
1227 s->proxy->id, s->id,
1228 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP",
1229 (s->admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001230 }
Willy Tarreaue6599732016-11-07 15:42:33 +01001231 else if (mode & SRV_ADMF_RMAINT) {
1232 chunk_printf(&trash,
1233 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
1234 s->flags & SRV_F_BACKUP ? "Backup " : "",
1235 s->proxy->id, s->id, s->hostname,
1236 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP",
1237 (s->admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
1238 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001239 else {
1240 chunk_printf(&trash,
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001241 "%sServer %s/%s is %s/%s (leaving maintenance)",
1242 s->flags & SRV_F_BACKUP ? "Backup " : "",
1243 s->proxy->id, s->id,
1244 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP",
1245 (s->admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
1246 srv_append_status(&trash, s, NULL, xferred, 0);
1247 }
1248 Warning("%s.\n", trash.str);
1249 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
1250 }
1251 else if ((mode & SRV_ADMF_DRAIN) && (s->admin & SRV_ADMF_DRAIN)) {
1252 /* remaining in drain mode after removing one of its flags */
1253
1254 if (mode & SRV_ADMF_FDRAIN) {
1255 chunk_printf(&trash,
1256 "%sServer %s/%s is leaving forced drain but remains in drain mode",
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001257 s->flags & SRV_F_BACKUP ? "Backup " : "",
1258 s->proxy->id, s->id);
1259
1260 if (s->track) /* normally it's mandatory here */
1261 chunk_appendf(&trash, " via %s/%s",
1262 s->track->proxy->id, s->track->id);
1263 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001264 else {
1265 chunk_printf(&trash,
1266 "%sServer %s/%s remains in forced drain mode",
1267 s->flags & SRV_F_BACKUP ? "Backup " : "",
1268 s->proxy->id, s->id);
1269 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001270 Warning("%s.\n", trash.str);
1271 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001272 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001273 else if (mode & SRV_ADMF_DRAIN) {
1274 /* OK completely leaving drain mode */
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001275 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
1276 if (s->proxy->last_change < now.tv_sec) // ignore negative times
1277 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
1278 s->proxy->last_change = now.tv_sec;
1279 }
1280
1281 if (s->last_change < now.tv_sec) // ignore negative times
1282 s->down_time += now.tv_sec - s->last_change;
1283 s->last_change = now.tv_sec;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001284 server_recalc_eweight(s);
1285
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001286 if (mode & SRV_ADMF_FDRAIN) {
1287 chunk_printf(&trash,
1288 "%sServer %s/%s is %s (leaving forced drain)",
1289 s->flags & SRV_F_BACKUP ? "Backup " : "",
1290 s->proxy->id, s->id,
1291 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP");
1292 }
1293 else {
1294 chunk_printf(&trash,
1295 "%sServer %s/%s is %s (leaving drain)",
1296 s->flags & SRV_F_BACKUP ? "Backup " : "",
1297 s->proxy->id, s->id,
1298 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP");
1299 if (s->track) /* normally it's mandatory here */
1300 chunk_appendf(&trash, " via %s/%s",
1301 s->track->proxy->id, s->track->id);
1302 }
1303 Warning("%s.\n", trash.str);
1304 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001305 }
1306
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001307 /* stop going down if the equivalent flag is still present (forced or inherited) */
1308 if (((mode & SRV_ADMF_MAINT) && (s->admin & SRV_ADMF_MAINT)) ||
1309 ((mode & SRV_ADMF_DRAIN) && (s->admin & SRV_ADMF_DRAIN)))
1310 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001311
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001312 if (mode & SRV_ADMF_MAINT)
1313 mode = SRV_ADMF_IMAINT;
1314 else if (mode & SRV_ADMF_DRAIN)
1315 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001316
1317 for (srv = s->trackers; srv; srv = srv->tracknext)
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001318 srv_clr_admin_flag(srv, mode);
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001319}
1320
Willy Tarreau757478e2016-11-03 19:22:19 +01001321/* principle: propagate maint and drain to tracking servers. This is useful
1322 * upon startup so that inherited states are correct.
1323 */
1324static void srv_propagate_admin_state(struct server *srv)
1325{
1326 struct server *srv2;
1327
1328 if (!srv->trackers)
1329 return;
1330
1331 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
1332 if (srv->admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001333 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001334
1335 if (srv->admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001336 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001337 }
1338}
1339
1340/* Compute and propagate the admin states for all servers in proxy <px>.
1341 * Only servers *not* tracking another one are considered, because other
1342 * ones will be handled when the server they track is visited.
1343 */
1344void srv_compute_all_admin_states(struct proxy *px)
1345{
1346 struct server *srv;
1347
1348 for (srv = px->srv; srv; srv = srv->next) {
1349 if (srv->track)
1350 continue;
1351 srv_propagate_admin_state(srv);
1352 }
1353}
1354
Willy Tarreaudff55432012-10-10 17:51:05 +02001355/* Note: must not be declared <const> as its list will be overwritten.
1356 * Please take care of keeping this list alphabetically sorted, doing so helps
1357 * all code contributors.
1358 * Optional keywords are also declared with a NULL ->parse() function so that
1359 * the config parser can report an appropriate error when a known keyword was
1360 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001361 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001362 */
1363static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille6e5e0d82017-03-20 16:30:18 +01001364 { "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 +01001365 { "agent-check", srv_parse_agent_check, 0, 1 }, /* Enable an auxiliary agent check */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001366 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille65aa3562017-03-14 11:20:13 +01001367 { "check", srv_parse_check, 0, 1 }, /* enable health checks */
Frédéric Lécaille25df8902017-03-10 14:04:31 +01001368 { "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 +01001369 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001370 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1371 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001372 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Frédéric Lécaille22f41a22017-03-16 17:17:36 +01001373 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001374 { "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 +01001375 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille65aa3562017-03-14 11:20:13 +01001376 { "no-check", srv_parse_no_check, 0, 1 }, /* disable health checks */
Frédéric Lécaille25df8902017-03-10 14:04:31 +01001377 { "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 +01001378 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1379 { "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 +01001380 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001381 { "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 +01001382 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001383 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1384 { "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 +02001385 { "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 +01001386 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001387 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Willy Tarreaudff55432012-10-10 17:51:05 +02001388 { NULL, NULL, 0 },
1389}};
1390
1391__attribute__((constructor))
1392static void __listener_init(void)
1393{
1394 srv_register_keywords(&srv_kws);
1395}
1396
Willy Tarreau004e0452013-11-21 11:22:01 +01001397/* Recomputes the server's eweight based on its state, uweight, the current time,
1398 * and the proxy's algorihtm. To be used after updating sv->uweight. The warmup
1399 * state is automatically disabled if the time is elapsed.
1400 */
1401void server_recalc_eweight(struct server *sv)
1402{
1403 struct proxy *px = sv->proxy;
1404 unsigned w;
1405
1406 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1407 /* go to full throttle if the slowstart interval is reached */
Willy Tarreau892337c2014-05-13 23:41:20 +02001408 if (sv->state == SRV_ST_STARTING)
1409 sv->state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001410 }
1411
1412 /* We must take care of not pushing the server to full throttle during slow starts.
1413 * It must also start immediately, at least at the minimal step when leaving maintenance.
1414 */
Willy Tarreau892337c2014-05-13 23:41:20 +02001415 if ((sv->state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001416 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1417 else
1418 w = px->lbprm.wdiv;
1419
1420 sv->eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
1421
1422 /* now propagate the status change to any LB algorithms */
1423 if (px->lbprm.update_server_eweight)
1424 px->lbprm.update_server_eweight(sv);
Willy Tarreau9943d312014-05-22 16:20:59 +02001425 else if (srv_is_usable(sv)) {
Willy Tarreau004e0452013-11-21 11:22:01 +01001426 if (px->lbprm.set_server_status_up)
1427 px->lbprm.set_server_status_up(sv);
1428 }
1429 else {
1430 if (px->lbprm.set_server_status_down)
1431 px->lbprm.set_server_status_down(sv);
1432 }
1433}
1434
Willy Tarreaubaaee002006-06-26 02:48:02 +02001435/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001436 * Parses weight_str and configures sv accordingly.
1437 * Returns NULL on success, error message string otherwise.
1438 */
1439const char *server_parse_weight_change_request(struct server *sv,
1440 const char *weight_str)
1441{
1442 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001443 long int w;
1444 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001445
1446 px = sv->proxy;
1447
1448 /* if the weight is terminated with '%', it is set relative to
1449 * the initial weight, otherwise it is absolute.
1450 */
1451 if (!*weight_str)
1452 return "Require <weight> or <weight%>.\n";
1453
Simon Hormanb796afa2013-02-12 10:45:53 +09001454 w = strtol(weight_str, &end, 10);
1455 if (end == weight_str)
1456 return "Empty weight string empty or preceded by garbage";
1457 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001458 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001459 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001460 /* Avoid integer overflow */
1461 if (w > 25600)
1462 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001463 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001464 if (w > 256)
1465 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001466 }
1467 else if (w < 0 || w > 256)
1468 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001469 else if (end[0] != '\0')
1470 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001471
1472 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1473 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1474
1475 sv->uweight = w;
Willy Tarreau004e0452013-11-21 11:22:01 +01001476 server_recalc_eweight(sv);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001477
1478 return NULL;
1479}
1480
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001481/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001482 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1483 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001484 * Returns:
1485 * - error string on error
1486 * - NULL on success
1487 */
1488const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001489 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001490{
1491 unsigned char ip[INET6_ADDRSTRLEN];
1492
1493 if (inet_pton(AF_INET6, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001494 update_server_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001495 return NULL;
1496 }
1497 if (inet_pton(AF_INET, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001498 update_server_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001499 return NULL;
1500 }
1501
1502 return "Could not understand IP address format.\n";
1503}
1504
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001505const char *server_parse_maxconn_change_request(struct server *sv,
1506 const char *maxconn_str)
1507{
1508 long int v;
1509 char *end;
1510
1511 if (!*maxconn_str)
1512 return "Require <maxconn>.\n";
1513
1514 v = strtol(maxconn_str, &end, 10);
1515 if (end == maxconn_str)
1516 return "maxconn string empty or preceded by garbage";
1517 else if (end[0] != '\0')
1518 return "Trailing garbage in maxconn string";
1519
1520 if (sv->maxconn == sv->minconn) { // static maxconn
1521 sv->maxconn = sv->minconn = v;
1522 } else { // dynamic maxconn
1523 sv->maxconn = v;
1524 }
1525
1526 if (may_dequeue_tasks(sv, sv->proxy))
1527 process_srv_queue(sv);
1528
1529 return NULL;
1530}
1531
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001532#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001533static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1534 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001535{
1536 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001537 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001538 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001539 NULL,
1540 };
1541
1542 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001543 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001544
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001545 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args);
1546}
1547
1548static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1549{
1550 struct sample_expr *expr;
1551
1552 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 +01001553 if (!expr) {
1554 memprintf(err, "error detected while parsing sni expression : %s", *err);
1555 return ERR_ALERT | ERR_FATAL;
1556 }
1557
1558 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1559 memprintf(err, "error detected while parsing sni expression : "
1560 " fetch method '%s' extracts information from '%s', "
1561 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001562 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001563 return ERR_ALERT | ERR_FATAL;
1564 }
1565
1566 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1567 release_sample_expr(newsrv->ssl_ctx.sni);
1568 newsrv->ssl_ctx.sni = expr;
1569
1570 return 0;
1571}
1572#endif
1573
1574static void display_parser_err(const char *file, int linenum, char **args, int cur_arg, char **err)
1575{
1576 if (err && *err) {
1577 indent_msg(err, 2);
1578 Alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], *err);
1579 }
1580 else
1581 Alert("parsing [%s:%d] : '%s %s' : error encountered while processing '%s'.\n",
1582 file, linenum, args[0], args[1], args[cur_arg]);
1583}
1584
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001585static void srv_conn_src_sport_range_cpy(struct server *srv,
1586 struct server *src)
1587{
1588 int range_sz;
1589
1590 range_sz = src->conn_src.sport_range->size;
1591 if (range_sz > 0) {
1592 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1593 if (srv->conn_src.sport_range != NULL) {
1594 int i;
1595
1596 for (i = 0; i < range_sz; i++) {
1597 srv->conn_src.sport_range->ports[i] =
1598 src->conn_src.sport_range->ports[i];
1599 }
1600 }
1601 }
1602}
1603
1604/*
1605 * Copy <src> server connection source settings to <srv> server everything needed.
1606 */
1607static void srv_conn_src_cpy(struct server *srv, struct server *src)
1608{
1609 srv->conn_src.opts = src->conn_src.opts;
1610 srv->conn_src.source_addr = src->conn_src.source_addr;
1611
1612 /* Source port range copy. */
1613 if (src->conn_src.sport_range != NULL)
1614 srv_conn_src_sport_range_cpy(srv, src);
1615
1616#ifdef CONFIG_HAP_TRANSPARENT
1617 if (src->conn_src.bind_hdr_name != NULL) {
1618 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1619 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1620 }
1621 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1622 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1623#endif
1624 if (src->conn_src.iface_name != NULL)
1625 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1626}
1627
1628/*
1629 * Copy <src> server SSL settings to <srv> server allocating
1630 * everything needed.
1631 */
1632#if defined(USE_OPENSSL)
1633static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1634{
1635 if (src->ssl_ctx.ca_file != NULL)
1636 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1637 if (src->ssl_ctx.crl_file != NULL)
1638 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
1639 if (src->ssl_ctx.client_crt != NULL)
1640 srv->ssl_ctx.client_crt = strdup(src->ssl_ctx.client_crt);
1641
1642 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1643
1644 if (src->ssl_ctx.verify_host != NULL)
1645 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1646 if (src->ssl_ctx.ciphers != NULL)
1647 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
1648 if (src->sni_expr != NULL)
1649 srv->sni_expr = strdup(src->sni_expr);
1650}
1651#endif
1652
1653/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001654 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001655 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001656 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001657 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001658static int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001659{
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001660 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001661 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001662
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001663 free(srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001664 srv->hostname = strdup(hostname);
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001665
Baptiste Assmann42746372017-05-03 12:12:02 +02001666 srv->hostname_dn_len = dns_str_to_dn_label_len(hostname);
1667 srv->hostname_dn = calloc(srv->hostname_dn_len + 1, sizeof(char));
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001668
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001669 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001670 goto err;
1671
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001672 if (!dns_str_to_dn_label(srv->hostname,
Baptiste Assmann42746372017-05-03 12:12:02 +02001673 srv->hostname_dn,
1674 srv->hostname_dn_len + 1))
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001675 goto err;
1676
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001677 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001678
1679 err:
1680 free(srv->hostname);
1681 srv->hostname = NULL;
Baptiste Assmann42746372017-05-03 12:12:02 +02001682 free(srv->hostname_dn);
1683 srv->hostname_dn = NULL;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001684 return -1;
1685}
1686
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001687/*
1688 * Free the link between a server and its resolution.
1689 * It also performs the following tasks:
1690 * - check if resolution can be moved back in the resolvers' pool
1691 * (and do it)
1692 * - move resolution's hostname_dn and hostname_dn_len to the next requester
1693 * available (when applied)
1694 */
1695static void srv_free_from_resolution(struct server *srv)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001696{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001697 struct dns_requester *requester;
1698 int count;
1699
1700 /* check if we can move the resolution back to the pool.
1701 * if <count> is greater than 1, then we can't */
1702 count = 0;
1703 list_for_each_entry(requester, &srv->resolution->requester.wait, list) {
1704 ++count;
1705 if (count > 1)
1706 break;
1707 }
1708 list_for_each_entry(requester, &srv->resolution->requester.curr, list) {
1709 ++count;
1710 if (count > 1)
1711 break;
1712 }
1713 if (count <= 1) {
1714 /* move the resolution back to the pool */
1715 dns_resolution_free(srv->resolvers, srv->resolution);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001716 return;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001717 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001718
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001719 dns_rm_requester_from_resolution(srv->dns_requester, srv->resolution);
1720
1721 return;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001722}
1723
1724/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001725 * Copy <src> server settings to <srv> server allocating
1726 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001727 * This function is not supposed to be called at any time, but only
1728 * during server settings parsing or during server allocations from
1729 * a server template, and just after having calloc()'ed a new server.
1730 * So, <src> may only be a default server (when parsing server settings)
1731 * or a server template (during server allocations from a server template).
1732 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1733 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001734 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001735static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001736{
1737 /* Connection source settings copy */
1738 srv_conn_src_cpy(srv, src);
1739
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001740 if (srv_tmpl) {
1741 srv->addr = src->addr;
1742 srv->svc_port = src->svc_port;
1743 }
1744
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001745 srv->pp_opts = src->pp_opts;
1746 if (src->rdr_pfx != NULL) {
1747 srv->rdr_pfx = strdup(src->rdr_pfx);
1748 srv->rdr_len = src->rdr_len;
1749 }
1750 if (src->cookie != NULL) {
1751 srv->cookie = strdup(src->cookie);
1752 srv->cklen = src->cklen;
1753 }
1754 srv->use_ssl = src->use_ssl;
1755 srv->check.addr = srv->agent.addr = src->check.addr;
1756 srv->check.use_ssl = src->check.use_ssl;
1757 srv->check.port = src->check.port;
1758 /* Note: 'flags' field has potentially been already initialized. */
1759 srv->flags |= src->flags;
1760 srv->do_check = src->do_check;
1761 srv->do_agent = src->do_agent;
1762 if (srv->check.port)
1763 srv->flags |= SRV_F_CHECKPORT;
1764 srv->check.inter = src->check.inter;
1765 srv->check.fastinter = src->check.fastinter;
1766 srv->check.downinter = src->check.downinter;
1767 srv->agent.use_ssl = src->agent.use_ssl;
1768 srv->agent.port = src->agent.port;
1769 if (src->agent.send_string != NULL)
1770 srv->agent.send_string = strdup(src->agent.send_string);
1771 srv->agent.send_string_len = src->agent.send_string_len;
1772 srv->agent.inter = src->agent.inter;
1773 srv->agent.fastinter = src->agent.fastinter;
1774 srv->agent.downinter = src->agent.downinter;
1775 srv->maxqueue = src->maxqueue;
1776 srv->minconn = src->minconn;
1777 srv->maxconn = src->maxconn;
1778 srv->slowstart = src->slowstart;
1779 srv->observe = src->observe;
1780 srv->onerror = src->onerror;
1781 srv->onmarkeddown = src->onmarkeddown;
1782 srv->onmarkedup = src->onmarkedup;
1783 if (src->trackit != NULL)
1784 srv->trackit = strdup(src->trackit);
1785 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1786 srv->uweight = srv->iweight = src->iweight;
1787
1788 srv->check.send_proxy = src->check.send_proxy;
1789 /* health: up, but will fall down at first failure */
1790 srv->check.rise = srv->check.health = src->check.rise;
1791 srv->check.fall = src->check.fall;
1792
1793 /* Here we check if 'disabled' is the default server state */
1794 if (src->admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1795 srv->admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1796 srv->state = SRV_ST_STOPPED;
1797 srv->check.state |= CHK_ST_PAUSED;
1798 srv->check.health = 0;
1799 }
1800
1801 /* health: up but will fall down at first failure */
1802 srv->agent.rise = srv->agent.health = src->agent.rise;
1803 srv->agent.fall = src->agent.fall;
1804
1805 if (src->resolvers_id != NULL)
1806 srv->resolvers_id = strdup(src->resolvers_id);
1807 srv->dns_opts.family_prio = src->dns_opts.family_prio;
1808 if (srv->dns_opts.family_prio == AF_UNSPEC)
1809 srv->dns_opts.family_prio = AF_INET6;
1810 memcpy(srv->dns_opts.pref_net,
1811 src->dns_opts.pref_net,
1812 sizeof srv->dns_opts.pref_net);
1813 srv->dns_opts.pref_net_nb = src->dns_opts.pref_net_nb;
1814
1815 srv->init_addr_methods = src->init_addr_methods;
1816 srv->init_addr = src->init_addr;
1817#if defined(USE_OPENSSL)
1818 srv_ssl_settings_cpy(srv, src);
1819#endif
1820#ifdef TCP_USER_TIMEOUT
1821 srv->tcp_ut = src->tcp_ut;
1822#endif
1823}
1824
1825static struct server *new_server(struct proxy *proxy)
1826{
1827 struct server *srv;
1828
1829 srv = calloc(1, sizeof *srv);
1830 if (!srv)
1831 return NULL;
1832
1833 srv->obj_type = OBJ_TYPE_SERVER;
1834 srv->proxy = proxy;
1835 LIST_INIT(&srv->actconns);
1836 LIST_INIT(&srv->pendconns);
1837 LIST_INIT(&srv->priv_conns);
1838 LIST_INIT(&srv->idle_conns);
1839 LIST_INIT(&srv->safe_conns);
1840
1841 srv->state = SRV_ST_RUNNING; /* early server setup */
1842 srv->last_change = now.tv_sec;
1843
1844 srv->check.status = HCHK_STATUS_INI;
1845 srv->check.server = srv;
1846 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
1847
1848 srv->agent.status = HCHK_STATUS_INI;
1849 srv->agent.server = srv;
1850 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
1851
1852 return srv;
1853}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001854
1855/*
1856 * Validate <srv> server health-check settings.
1857 * Returns 0 if everything is OK, -1 if not.
1858 */
1859static int server_healthcheck_validate(const char *file, int linenum, struct server *srv)
1860{
1861 struct tcpcheck_rule *r = NULL;
1862 struct list *l;
1863
1864 /*
1865 * We need at least a service port, a check port or the first tcp-check rule must
1866 * be a 'connect' one when checking an IPv4/IPv6 server.
1867 */
1868 if ((srv_check_healthcheck_port(&srv->check) != 0) ||
1869 (!is_inet_addr(&srv->check.addr) && (is_addr(&srv->check.addr) || !is_inet_addr(&srv->addr))))
1870 return 0;
1871
1872 r = (struct tcpcheck_rule *)srv->proxy->tcpcheck_rules.n;
1873 if (!r) {
1874 Alert("parsing [%s:%d] : server %s has neither service port nor check port. "
1875 "Check has been disabled.\n",
1876 file, linenum, srv->id);
1877 return -1;
1878 }
1879
1880 /* search the first action (connect / send / expect) in the list */
1881 l = &srv->proxy->tcpcheck_rules;
1882 list_for_each_entry(r, l, list) {
1883 if (r->action != TCPCHK_ACT_COMMENT)
1884 break;
1885 }
1886
1887 if ((r->action != TCPCHK_ACT_CONNECT) || !r->port) {
1888 Alert("parsing [%s:%d] : server %s has neither service port nor check port "
1889 "nor tcp_check rule 'connect' with port information. Check has been disabled.\n",
1890 file, linenum, srv->id);
1891 return -1;
1892 }
1893
1894 /* scan the tcp-check ruleset to ensure a port has been configured */
1895 l = &srv->proxy->tcpcheck_rules;
1896 list_for_each_entry(r, l, list) {
1897 if ((r->action == TCPCHK_ACT_CONNECT) && (!r->port)) {
1898 Alert("parsing [%s:%d] : server %s has neither service port nor check port, "
1899 "and a tcp_check rule 'connect' with no port information. Check has been disabled.\n",
1900 file, linenum, srv->id);
1901 return -1;
1902 }
1903 }
1904
1905 return 0;
1906}
1907
1908/*
1909 * Initialize <srv> health-check structure.
1910 * Returns the error string in case of memory allocation failure, NULL if not.
1911 */
1912static const char *do_health_check_init(struct server *srv, int check_type, int state)
1913{
1914 const char *ret;
1915
1916 if (!srv->do_check)
1917 return NULL;
1918
1919 ret = init_check(&srv->check, check_type);
1920 if (ret)
1921 return ret;
1922
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001923 srv->check.state |= state;
1924 global.maxsock++;
1925
1926 return NULL;
1927}
1928
1929static int server_health_check_init(const char *file, int linenum,
1930 struct server *srv, struct proxy *curproxy)
1931{
1932 const char *ret;
1933
1934 if (!srv->do_check)
1935 return 0;
1936
1937 if (srv->trackit) {
1938 Alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1939 file, linenum);
1940 return ERR_ALERT | ERR_FATAL;
1941 }
1942
1943 if (server_healthcheck_validate(file, linenum, srv) < 0)
1944 return ERR_ALERT | ERR_ABORT;
1945
1946 /* note: check type will be set during the config review phase */
1947 ret = do_health_check_init(srv, 0, CHK_ST_CONFIGURED | CHK_ST_ENABLED);
1948 if (ret) {
1949 Alert("parsing [%s:%d] : %s.\n", file, linenum, ret);
1950 return ERR_ALERT | ERR_ABORT;
1951 }
1952
1953 return 0;
1954}
1955
1956/*
1957 * Initialize <srv> agent check structure.
1958 * Returns the error string in case of memory allocation failure, NULL if not.
1959 */
1960static const char *do_server_agent_check_init(struct server *srv, int state)
1961{
1962 const char *ret;
1963
1964 if (!srv->do_agent)
1965 return NULL;
1966
1967 ret = init_check(&srv->agent, PR_O2_LB_AGENT_CHK);
1968 if (ret)
1969 return ret;
1970
1971 if (!srv->agent.inter)
1972 srv->agent.inter = srv->check.inter;
1973
1974 srv->agent.state |= state;
1975 global.maxsock++;
1976
1977 return NULL;
1978}
1979
1980static int server_agent_check_init(const char *file, int linenum,
1981 struct server *srv, struct proxy *curproxy)
1982{
1983 const char *ret;
1984
1985 if (!srv->do_agent)
1986 return 0;
1987
1988 if (!srv->agent.port) {
1989 Alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
1990 file, linenum, srv->id);
1991 return ERR_ALERT | ERR_FATAL;
1992 }
1993
1994 ret = do_server_agent_check_init(srv, CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT);
1995 if (ret) {
1996 Alert("parsing [%s:%d] : %s.\n", file, linenum, ret);
1997 return ERR_ALERT | ERR_ABORT;
1998 }
1999
2000 return 0;
2001}
2002
2003#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2004static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
2005 struct server *srv, struct proxy *proxy)
2006{
2007 int ret;
2008 char *err = NULL;
2009
2010 if (!srv->sni_expr)
2011 return 0;
2012
2013 ret = server_parse_sni_expr(srv, proxy, &err);
2014 if (!ret)
2015 return 0;
2016
2017 display_parser_err(file, linenum, args, cur_arg, &err);
2018 free(err);
2019
2020 return ret;
2021}
2022#endif
2023
2024/*
2025 * Server initializations finalization.
2026 * Initialize health check, agent check and SNI expression if enabled.
2027 * Must not be called for a default server instance.
2028 */
2029static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
2030 struct server *srv, struct proxy *px)
2031{
2032 int ret;
2033
2034 if ((ret = server_health_check_init(file, linenum, srv, px)) != 0 ||
2035 (ret = server_agent_check_init(file, linenum, srv, px)) != 0) {
2036 return ret;
2037 }
2038
2039#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2040 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
2041 return ret;
2042#endif
2043
2044 if (srv->flags & SRV_F_BACKUP)
2045 px->srv_bck++;
2046 else
2047 px->srv_act++;
2048 srv_lb_commit_status(srv);
2049
2050 return 0;
2051}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002052
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002053/*
2054 * Parse as much as possible such a range string argument: low[-high]
2055 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
2056 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
2057 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
2058 * Returns 0 if succeeded, -1 if not.
2059 */
2060static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
2061{
2062 char *nb_high_arg;
2063
2064 *nb_high = 0;
2065 chunk_printf(&trash, "%s", arg);
2066 *nb_low = atoi(trash.str);
2067
2068 if ((nb_high_arg = strchr(trash.str, '-'))) {
2069 *nb_high_arg++ = '\0';
2070 *nb_high = atoi(nb_high_arg);
2071 }
2072 else {
2073 *nb_high += *nb_low;
2074 *nb_low = 1;
2075 }
2076
2077 if (*nb_low < 0 || *nb_high < *nb_low)
2078 return -1;
2079
2080 return 0;
2081}
2082
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002083static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
2084{
2085 chunk_printf(&trash, "%s%d", prefix, nb);
2086 free(srv->id);
2087 srv->id = strdup(trash.str);
2088}
2089
2090/*
2091 * Initialize as much as possible servers from <srv> server template.
2092 * Note that a server template is a special server with
2093 * a few different parameters than a server which has
2094 * been parsed mostly the same way as a server.
2095 * Returns the number of servers succesfully allocated,
2096 * 'srv' template included.
2097 */
2098static int server_template_init(struct server *srv, struct proxy *px)
2099{
2100 int i;
2101 struct server *newsrv;
2102
2103 for (i = srv->tmpl_info.nb_low + 1; i <= srv->tmpl_info.nb_high; i++) {
2104 int check_init_state;
2105 int agent_init_state;
2106
2107 newsrv = new_server(px);
2108 if (!newsrv)
2109 goto err;
2110
2111 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002112 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002113#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2114 if (newsrv->sni_expr) {
2115 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
2116 if (!newsrv->ssl_ctx.sni)
2117 goto err;
2118 }
2119#endif
2120 /* Set this new server ID. */
2121 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
2122
2123 /* Initial checks states. */
2124 check_init_state = CHK_ST_CONFIGURED | CHK_ST_ENABLED;
2125 agent_init_state = CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT;
2126
2127 if (do_health_check_init(newsrv, px->options2 & PR_O2_CHK_ANY, check_init_state) ||
2128 do_server_agent_check_init(newsrv, agent_init_state))
2129 goto err;
2130
2131 /* Linked backwards first. This will be restablished after parsing. */
2132 newsrv->next = px->srv;
2133 px->srv = newsrv;
2134 }
2135 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
2136
2137 return i - srv->tmpl_info.nb_low;
2138
2139 err:
2140 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
2141 if (newsrv) {
2142#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2143 release_sample_expr(newsrv->ssl_ctx.sni);
2144#endif
2145 free_check(&newsrv->agent);
2146 free_check(&newsrv->check);
2147 }
2148 free(newsrv);
2149 return i - srv->tmpl_info.nb_low;
2150}
2151
Willy Tarreau272adea2014-03-31 10:39:59 +02002152int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy, struct proxy *defproxy)
2153{
2154 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002155 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02002156 char *errmsg = NULL;
2157 int err_code = 0;
2158 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02002159 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02002160
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002161 if (!strcmp(args[0], "server") ||
2162 !strcmp(args[0], "default-server") ||
2163 !strcmp(args[0], "server-template")) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002164 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01002165 int defsrv = (*args[0] == 'd');
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002166 int srv = !defsrv && !strcmp(args[0], "server");
2167 int srv_tmpl = !defsrv && !srv;
2168 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002169
2170 if (!defsrv && curproxy == defproxy) {
2171 Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
2172 err_code |= ERR_ALERT | ERR_FATAL;
2173 goto out;
2174 }
2175 else if (warnifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL))
2176 err_code |= ERR_ALERT | ERR_FATAL;
2177
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002178 /* There is no mandatory first arguments for default server. */
2179 if (srv) {
2180 if (!*args[2]) {
2181 /* 'server' line number of argument check. */
2182 Alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
2183 file, linenum, args[0]);
2184 err_code |= ERR_ALERT | ERR_FATAL;
2185 goto out;
2186 }
2187
2188 err = invalid_char(args[1]);
2189 }
2190 else if (srv_tmpl) {
2191 if (!*args[3]) {
2192 /* 'server-template' line number of argument check. */
2193 Alert("parsing [%s:%d] : '%s' expects <prefix> <nb | range> <addr>[:<port>] as arguments.\n",
2194 file, linenum, args[0]);
2195 err_code |= ERR_ALERT | ERR_FATAL;
2196 goto out;
2197 }
2198
2199 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002200 }
2201
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002202 if (err) {
2203 Alert("parsing [%s:%d] : character '%c' is not permitted in %s %s '%s'.\n",
2204 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002205 err_code |= ERR_ALERT | ERR_FATAL;
2206 goto out;
2207 }
2208
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002209 cur_arg = 2;
2210 if (srv_tmpl) {
2211 /* Parse server-template <nb | range> arg. */
2212 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
2213 Alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
2214 file, linenum, args[0], args[cur_arg]);
2215 err_code |= ERR_ALERT | ERR_FATAL;
2216 goto out;
2217 }
2218 cur_arg++;
2219 }
2220
Willy Tarreau272adea2014-03-31 10:39:59 +02002221 if (!defsrv) {
2222 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002223 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002224 struct protocol *proto;
2225
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002226 newsrv = new_server(curproxy);
2227 if (!newsrv) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002228 Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
2229 err_code |= ERR_ALERT | ERR_ABORT;
2230 goto out;
2231 }
2232
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002233 if (srv_tmpl) {
2234 newsrv->tmpl_info.nb_low = tmpl_range_low;
2235 newsrv->tmpl_info.nb_high = tmpl_range_high;
2236 }
2237
Willy Tarreau272adea2014-03-31 10:39:59 +02002238 /* the servers are linked backwards first */
2239 newsrv->next = curproxy->srv;
2240 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02002241 newsrv->conf.file = strdup(file);
2242 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002243 /* Note: for a server template, its id is its prefix.
2244 * This is a temporary id which will be used for server allocations to come
2245 * after parsing.
2246 */
2247 if (srv)
2248 newsrv->id = strdup(args[1]);
2249 else
2250 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002251
2252 /* several ways to check the port component :
2253 * - IP => port=+0, relative (IPv4 only)
2254 * - IP: => port=+0, relative
2255 * - IP:N => port=N, absolute
2256 * - IP:+N => port=+N, relative
2257 * - IP:-N => port=-N, relative
2258 */
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002259 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, &errmsg, NULL, &fqdn, 0);
Willy Tarreau272adea2014-03-31 10:39:59 +02002260 if (!sk) {
2261 Alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
2262 err_code |= ERR_ALERT | ERR_FATAL;
2263 goto out;
2264 }
2265
2266 proto = protocol_by_family(sk->ss_family);
Willy Tarreau9698f4b2017-01-06 18:42:57 +01002267 if (!fqdn && (!proto || !proto->connect)) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002268 Alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
2269 file, linenum, args[0], args[1]);
2270 err_code |= ERR_ALERT | ERR_FATAL;
2271 goto out;
2272 }
2273
2274 if (!port1 || !port2) {
2275 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002276 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002277 }
2278 else if (port1 != port2) {
2279 /* port range */
2280 Alert("parsing [%s:%d] : '%s %s' : port ranges are not allowed in '%s'\n",
2281 file, linenum, args[0], args[1], args[2]);
2282 err_code |= ERR_ALERT | ERR_FATAL;
2283 goto out;
2284 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002285
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002286 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002287 if (fqdn) {
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002288 if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002289 Alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
2290 file, linenum, newsrv->id);
2291 err_code |= ERR_ALERT | ERR_FATAL;
2292 goto out;
2293 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002294 }
2295
Willy Tarreau272adea2014-03-31 10:39:59 +02002296 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002297 newsrv->svc_port = port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002298
Willy Tarreau9698f4b2017-01-06 18:42:57 +01002299 if (!newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002300 Alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002301 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002302 err_code |= ERR_ALERT | ERR_FATAL;
2303 goto out;
2304 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002305
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002306 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002307 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002308 cur_arg++;
Willy Tarreau272adea2014-03-31 10:39:59 +02002309 } else {
2310 newsrv = &curproxy->defsrv;
2311 cur_arg = 1;
Thierry Fournierada34842016-02-17 21:25:09 +01002312 newsrv->dns_opts.family_prio = AF_INET6;
Willy Tarreau272adea2014-03-31 10:39:59 +02002313 }
2314
2315 while (*args[cur_arg]) {
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01002316 if (!strcmp(args[cur_arg], "agent-inter")) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002317 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2318 if (err) {
2319 Alert("parsing [%s:%d] : unexpected character '%c' in 'agent-inter' argument of server %s.\n",
2320 file, linenum, *err, newsrv->id);
2321 err_code |= ERR_ALERT | ERR_FATAL;
2322 goto out;
2323 }
2324 if (val <= 0) {
2325 Alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
2326 file, linenum, val, args[cur_arg], newsrv->id);
2327 err_code |= ERR_ALERT | ERR_FATAL;
2328 goto out;
2329 }
2330 newsrv->agent.inter = val;
2331 cur_arg += 2;
2332 }
Misiekea849332017-01-09 09:39:51 +01002333 else if (!strcmp(args[cur_arg], "agent-addr")) {
2334 if(str2ip(args[cur_arg + 1], &newsrv->agent.addr) == NULL) {
2335 Alert("parsing agent-addr failed. Check if %s is correct address.\n", args[cur_arg + 1]);
2336 goto out;
2337 }
2338
2339 cur_arg += 2;
2340 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002341 else if (!strcmp(args[cur_arg], "agent-port")) {
2342 global.maxsock++;
2343 newsrv->agent.port = atol(args[cur_arg + 1]);
2344 cur_arg += 2;
2345 }
James Brown55f9ff12015-10-21 18:19:05 -07002346 else if (!strcmp(args[cur_arg], "agent-send")) {
2347 global.maxsock++;
2348 free(newsrv->agent.send_string);
2349 newsrv->agent.send_string_len = strlen(args[cur_arg + 1]);
2350 newsrv->agent.send_string = calloc(1, newsrv->agent.send_string_len + 1);
2351 memcpy(newsrv->agent.send_string, args[cur_arg + 1], newsrv->agent.send_string_len);
2352 cur_arg += 2;
2353 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002354 else if (!strcmp(args[cur_arg], "init-addr")) {
2355 char *p, *end;
2356 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002357 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002358
2359 newsrv->init_addr_methods = 0;
2360 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2361
2362 for (p = args[cur_arg + 1]; *p; p = end) {
2363 /* cut on next comma */
2364 for (end = p; *end && *end != ','; end++);
2365 if (*end)
2366 *(end++) = 0;
2367
Willy Tarreau4310d362016-11-02 15:05:56 +01002368 memset(&sa, 0, sizeof(sa));
Baptiste Assmann25938272016-09-21 20:26:16 +02002369 if (!strcmp(p, "libc")) {
2370 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2371 }
2372 else if (!strcmp(p, "last")) {
2373 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2374 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01002375 else if (!strcmp(p, "none")) {
2376 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2377 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002378 else if (str2ip2(p, &sa, 0)) {
2379 if (is_addr(&newsrv->init_addr)) {
2380 Alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
2381 file, linenum, args[cur_arg], p);
2382 err_code |= ERR_ALERT | ERR_FATAL;
2383 goto out;
2384 }
2385 newsrv->init_addr = sa;
2386 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2387 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002388 else {
Willy Tarreau37ebe122016-11-04 15:17:58 +01002389 Alert("parsing [%s:%d]: '%s' : unknown init-addr method '%s', supported methods are 'libc', 'last', 'none'.\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002390 file, linenum, args[cur_arg], p);
2391 err_code |= ERR_ALERT | ERR_FATAL;
2392 goto out;
2393 }
2394 if (!done) {
2395 Alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
2396 file, linenum, args[cur_arg], p);
2397 err_code |= ERR_ALERT | ERR_FATAL;
2398 goto out;
2399 }
2400 }
2401 cur_arg += 2;
2402 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002403 else if (!strcmp(args[cur_arg], "resolvers")) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002404 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002405 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2406 cur_arg += 2;
2407 }
2408 else if (!strcmp(args[cur_arg], "resolve-prefer")) {
2409 if (!strcmp(args[cur_arg + 1], "ipv4"))
Thierry Fournierada34842016-02-17 21:25:09 +01002410 newsrv->dns_opts.family_prio = AF_INET;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002411 else if (!strcmp(args[cur_arg + 1], "ipv6"))
Thierry Fournierada34842016-02-17 21:25:09 +01002412 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002413 else {
2414 Alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
2415 file, linenum, args[cur_arg]);
2416 err_code |= ERR_ALERT | ERR_FATAL;
2417 goto out;
2418 }
2419 cur_arg += 2;
2420 }
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002421 else if (!strcmp(args[cur_arg], "resolve-net")) {
2422 char *p, *e;
2423 unsigned char mask;
2424 struct dns_options *opt;
2425
2426 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
2427 Alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
2428 file, linenum, args[cur_arg]);
2429 err_code |= ERR_ALERT | ERR_FATAL;
2430 goto out;
2431 }
2432
2433 opt = &newsrv->dns_opts;
2434
2435 /* Split arguments by comma, and convert it from ipv4 or ipv6
2436 * string network in in_addr or in6_addr.
2437 */
2438 p = args[cur_arg + 1];
2439 e = p;
2440 while (*p != '\0') {
2441 /* If no room avalaible, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002442 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002443 Alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
2444 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2445 err_code |= ERR_ALERT | ERR_FATAL;
2446 goto out;
2447 }
2448 /* look for end or comma. */
2449 while (*e != ',' && *e != '\0')
2450 e++;
2451 if (*e == ',') {
2452 *e = '\0';
2453 e++;
2454 }
2455 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2456 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2457 /* Try to convert input string from ipv4 or ipv6 network. */
2458 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2459 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2460 &mask)) {
2461 /* Try to convert input string from ipv6 network. */
2462 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2463 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2464 } else {
2465 /* All network conversions fail, retrun error. */
2466 Alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
2467 file, linenum, args[cur_arg], p);
2468 err_code |= ERR_ALERT | ERR_FATAL;
2469 goto out;
2470 }
2471 opt->pref_net_nb++;
2472 p = e;
2473 }
2474
2475 cur_arg += 2;
2476 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002477 else if (!strcmp(args[cur_arg], "rise")) {
2478 if (!*args[cur_arg + 1]) {
2479 Alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
2480 file, linenum, args[cur_arg]);
2481 err_code |= ERR_ALERT | ERR_FATAL;
2482 goto out;
2483 }
2484
2485 newsrv->check.rise = atol(args[cur_arg + 1]);
2486 if (newsrv->check.rise <= 0) {
2487 Alert("parsing [%s:%d]: '%s' has to be > 0.\n",
2488 file, linenum, args[cur_arg]);
2489 err_code |= ERR_ALERT | ERR_FATAL;
2490 goto out;
2491 }
2492
2493 if (newsrv->check.health)
2494 newsrv->check.health = newsrv->check.rise;
2495 cur_arg += 2;
2496 }
2497 else if (!strcmp(args[cur_arg], "fall")) {
2498 newsrv->check.fall = atol(args[cur_arg + 1]);
2499
2500 if (!*args[cur_arg + 1]) {
2501 Alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
2502 file, linenum, args[cur_arg]);
2503 err_code |= ERR_ALERT | ERR_FATAL;
2504 goto out;
2505 }
2506
2507 if (newsrv->check.fall <= 0) {
2508 Alert("parsing [%s:%d]: '%s' has to be > 0.\n",
2509 file, linenum, args[cur_arg]);
2510 err_code |= ERR_ALERT | ERR_FATAL;
2511 goto out;
2512 }
2513
2514 cur_arg += 2;
2515 }
2516 else if (!strcmp(args[cur_arg], "inter")) {
2517 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2518 if (err) {
2519 Alert("parsing [%s:%d] : unexpected character '%c' in 'inter' argument of server %s.\n",
2520 file, linenum, *err, newsrv->id);
2521 err_code |= ERR_ALERT | ERR_FATAL;
2522 goto out;
2523 }
2524 if (val <= 0) {
2525 Alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
2526 file, linenum, val, args[cur_arg], newsrv->id);
2527 err_code |= ERR_ALERT | ERR_FATAL;
2528 goto out;
2529 }
2530 newsrv->check.inter = val;
2531 cur_arg += 2;
2532 }
2533 else if (!strcmp(args[cur_arg], "fastinter")) {
2534 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2535 if (err) {
2536 Alert("parsing [%s:%d]: unexpected character '%c' in 'fastinter' argument of server %s.\n",
2537 file, linenum, *err, newsrv->id);
2538 err_code |= ERR_ALERT | ERR_FATAL;
2539 goto out;
2540 }
2541 if (val <= 0) {
2542 Alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
2543 file, linenum, val, args[cur_arg], newsrv->id);
2544 err_code |= ERR_ALERT | ERR_FATAL;
2545 goto out;
2546 }
2547 newsrv->check.fastinter = val;
2548 cur_arg += 2;
2549 }
2550 else if (!strcmp(args[cur_arg], "downinter")) {
2551 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2552 if (err) {
2553 Alert("parsing [%s:%d]: unexpected character '%c' in 'downinter' argument of server %s.\n",
2554 file, linenum, *err, newsrv->id);
2555 err_code |= ERR_ALERT | ERR_FATAL;
2556 goto out;
2557 }
2558 if (val <= 0) {
2559 Alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
2560 file, linenum, val, args[cur_arg], newsrv->id);
2561 err_code |= ERR_ALERT | ERR_FATAL;
2562 goto out;
2563 }
2564 newsrv->check.downinter = val;
2565 cur_arg += 2;
2566 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002567 else if (!strcmp(args[cur_arg], "port")) {
2568 newsrv->check.port = atol(args[cur_arg + 1]);
Baptiste Assmann6b453f12016-08-11 23:12:18 +02002569 newsrv->flags |= SRV_F_CHECKPORT;
Willy Tarreau272adea2014-03-31 10:39:59 +02002570 cur_arg += 2;
2571 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002572 else if (!strcmp(args[cur_arg], "weight")) {
2573 int w;
2574 w = atol(args[cur_arg + 1]);
2575 if (w < 0 || w > SRV_UWGHT_MAX) {
2576 Alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
2577 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2578 err_code |= ERR_ALERT | ERR_FATAL;
2579 goto out;
2580 }
2581 newsrv->uweight = newsrv->iweight = w;
2582 cur_arg += 2;
2583 }
2584 else if (!strcmp(args[cur_arg], "minconn")) {
2585 newsrv->minconn = atol(args[cur_arg + 1]);
2586 cur_arg += 2;
2587 }
2588 else if (!strcmp(args[cur_arg], "maxconn")) {
2589 newsrv->maxconn = atol(args[cur_arg + 1]);
2590 cur_arg += 2;
2591 }
2592 else if (!strcmp(args[cur_arg], "maxqueue")) {
2593 newsrv->maxqueue = atol(args[cur_arg + 1]);
2594 cur_arg += 2;
2595 }
2596 else if (!strcmp(args[cur_arg], "slowstart")) {
2597 /* slowstart is stored in seconds */
2598 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2599 if (err) {
2600 Alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
2601 file, linenum, *err, newsrv->id);
2602 err_code |= ERR_ALERT | ERR_FATAL;
2603 goto out;
2604 }
2605 newsrv->slowstart = (val + 999) / 1000;
2606 cur_arg += 2;
2607 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002608 else if (!strcmp(args[cur_arg], "on-error")) {
2609 if (!strcmp(args[cur_arg + 1], "fastinter"))
2610 newsrv->onerror = HANA_ONERR_FASTINTER;
2611 else if (!strcmp(args[cur_arg + 1], "fail-check"))
2612 newsrv->onerror = HANA_ONERR_FAILCHK;
2613 else if (!strcmp(args[cur_arg + 1], "sudden-death"))
2614 newsrv->onerror = HANA_ONERR_SUDDTH;
2615 else if (!strcmp(args[cur_arg + 1], "mark-down"))
2616 newsrv->onerror = HANA_ONERR_MARKDWN;
2617 else {
2618 Alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
2619 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2620 file, linenum, args[cur_arg], args[cur_arg + 1]);
2621 err_code |= ERR_ALERT | ERR_FATAL;
2622 goto out;
2623 }
2624
2625 cur_arg += 2;
2626 }
2627 else if (!strcmp(args[cur_arg], "on-marked-down")) {
2628 if (!strcmp(args[cur_arg + 1], "shutdown-sessions"))
2629 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2630 else {
2631 Alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
2632 file, linenum, args[cur_arg], args[cur_arg + 1]);
2633 err_code |= ERR_ALERT | ERR_FATAL;
2634 goto out;
2635 }
2636
2637 cur_arg += 2;
2638 }
2639 else if (!strcmp(args[cur_arg], "on-marked-up")) {
2640 if (!strcmp(args[cur_arg + 1], "shutdown-backup-sessions"))
2641 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2642 else {
2643 Alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
2644 file, linenum, args[cur_arg], args[cur_arg + 1]);
2645 err_code |= ERR_ALERT | ERR_FATAL;
2646 goto out;
2647 }
2648
2649 cur_arg += 2;
2650 }
2651 else if (!strcmp(args[cur_arg], "error-limit")) {
2652 if (!*args[cur_arg + 1]) {
2653 Alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
2654 file, linenum, args[cur_arg]);
2655 err_code |= ERR_ALERT | ERR_FATAL;
2656 goto out;
2657 }
2658
2659 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2660
2661 if (newsrv->consecutive_errors_limit <= 0) {
2662 Alert("parsing [%s:%d]: %s has to be > 0.\n",
2663 file, linenum, args[cur_arg]);
2664 err_code |= ERR_ALERT | ERR_FATAL;
2665 goto out;
2666 }
2667 cur_arg += 2;
2668 }
Frédéric Lécaille8d083ed2017-04-14 15:19:56 +02002669 else if (!strcmp(args[cur_arg], "usesrc")) { /* address to use outside: needs "source" first */
Willy Tarreau272adea2014-03-31 10:39:59 +02002670 Alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
2671 file, linenum, "usesrc", "source");
2672 err_code |= ERR_ALERT | ERR_FATAL;
2673 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002674 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002675 else {
2676 static int srv_dumped;
2677 struct srv_kw *kw;
2678 char *err;
2679
2680 kw = srv_find_kw(args[cur_arg]);
2681 if (kw) {
2682 char *err = NULL;
2683 int code;
2684
2685 if (!kw->parse) {
2686 Alert("parsing [%s:%d] : '%s %s' : '%s' option is not implemented in this version (check build options).\n",
2687 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002688 if (kw->skip != -1)
2689 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002690 err_code |= ERR_ALERT | ERR_FATAL;
2691 goto out;
2692 }
2693
2694 if (defsrv && !kw->default_ok) {
2695 Alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
2696 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002697 if (kw->skip != -1)
2698 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002699 err_code |= ERR_ALERT;
2700 continue;
2701 }
2702
2703 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2704 err_code |= code;
2705
2706 if (code) {
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01002707 display_parser_err(file, linenum, args, cur_arg, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002708 if (code & ERR_FATAL) {
2709 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002710 if (kw->skip != -1)
2711 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002712 goto out;
2713 }
2714 }
2715 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002716 if (kw->skip != -1)
2717 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002718 continue;
2719 }
2720
2721 err = NULL;
2722 if (!srv_dumped) {
2723 srv_dump_kws(&err);
2724 indent_msg(&err, 4);
2725 srv_dumped = 1;
2726 }
2727
2728 Alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
2729 file, linenum, args[0], args[1], args[cur_arg],
2730 err ? " Registered keywords :" : "", err ? err : "");
2731 free(err);
2732
2733 err_code |= ERR_ALERT | ERR_FATAL;
2734 goto out;
2735 }
2736 }
2737
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002738 if (!defsrv)
2739 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2740 if (err_code & ERR_FATAL)
2741 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002742 if (srv_tmpl)
2743 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002744 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002745 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002746 return 0;
2747
2748 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002749 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002750 free(errmsg);
2751 return err_code;
2752}
2753
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002754/* Returns a pointer to the first server matching either id <id>.
2755 * NULL is returned if no match is found.
2756 * the lookup is performed in the backend <bk>
2757 */
2758struct server *server_find_by_id(struct proxy *bk, int id)
2759{
2760 struct eb32_node *eb32;
2761 struct server *curserver;
2762
2763 if (!bk || (id ==0))
2764 return NULL;
2765
2766 /* <bk> has no backend capabilities, so it can't have a server */
2767 if (!(bk->cap & PR_CAP_BE))
2768 return NULL;
2769
2770 curserver = NULL;
2771
2772 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2773 if (eb32)
2774 curserver = container_of(eb32, struct server, conf.id);
2775
2776 return curserver;
2777}
2778
2779/* Returns a pointer to the first server matching either name <name>, or id
2780 * if <name> starts with a '#'. NULL is returned if no match is found.
2781 * the lookup is performed in the backend <bk>
2782 */
2783struct server *server_find_by_name(struct proxy *bk, const char *name)
2784{
2785 struct server *curserver;
2786
2787 if (!bk || !name)
2788 return NULL;
2789
2790 /* <bk> has no backend capabilities, so it can't have a server */
2791 if (!(bk->cap & PR_CAP_BE))
2792 return NULL;
2793
2794 curserver = NULL;
2795 if (*name == '#') {
2796 curserver = server_find_by_id(bk, atoi(name + 1));
2797 if (curserver)
2798 return curserver;
2799 }
2800 else {
2801 curserver = bk->srv;
2802
2803 while (curserver && (strcmp(curserver->id, name) != 0))
2804 curserver = curserver->next;
2805
2806 if (curserver)
2807 return curserver;
2808 }
2809
2810 return NULL;
2811}
2812
2813struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2814{
2815 struct server *byname;
2816 struct server *byid;
2817
2818 if (!name && !id)
2819 return NULL;
2820
2821 if (diff)
2822 *diff = 0;
2823
2824 byname = byid = NULL;
2825
2826 if (name) {
2827 byname = server_find_by_name(bk, name);
2828 if (byname && (!id || byname->puid == id))
2829 return byname;
2830 }
2831
2832 /* remaining possibilities :
2833 * - name not set
2834 * - name set but not found
2835 * - name found but ID doesn't match
2836 */
2837 if (id) {
2838 byid = server_find_by_id(bk, id);
2839 if (byid) {
2840 if (byname) {
2841 /* use id only if forced by configuration */
2842 if (byid->flags & SRV_F_FORCED_ID) {
2843 if (diff)
2844 *diff |= 2;
2845 return byid;
2846 }
2847 else {
2848 if (diff)
2849 *diff |= 1;
2850 return byname;
2851 }
2852 }
2853
2854 /* remaining possibilities:
2855 * - name not set
2856 * - name set but not found
2857 */
2858 if (name && diff)
2859 *diff |= 2;
2860 return byid;
2861 }
2862
2863 /* id bot found */
2864 if (byname) {
2865 if (diff)
2866 *diff |= 1;
2867 return byname;
2868 }
2869 }
2870
2871 return NULL;
2872}
2873
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002874/* Update a server state using the parameters available in the params list */
2875static void srv_update_state(struct server *srv, int version, char **params)
2876{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002877 char *p;
Willy Tarreau31138fa2015-09-29 18:38:47 +02002878 struct chunk *msg;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002879
2880 /* fields since version 1
2881 * and common to all other upcoming versions
2882 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002883 enum srv_state srv_op_state;
2884 enum srv_admin srv_admin_state;
2885 unsigned srv_uweight, srv_iweight;
2886 unsigned long srv_last_time_change;
2887 short srv_check_status;
2888 enum chk_result srv_check_result;
2889 int srv_check_health;
2890 int srv_check_state, srv_agent_state;
2891 int bk_f_forced_id;
2892 int srv_f_forced_id;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002893 int fqdn_set_by_cli;
2894 const char *fqdn;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002895
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002896 fqdn = NULL;
Willy Tarreau31138fa2015-09-29 18:38:47 +02002897 msg = get_trash_chunk();
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002898 switch (version) {
2899 case 1:
2900 /*
2901 * now we can proceed with server's state update:
2902 * srv_addr: params[0]
2903 * srv_op_state: params[1]
2904 * srv_admin_state: params[2]
2905 * srv_uweight: params[3]
2906 * srv_iweight: params[4]
2907 * srv_last_time_change: params[5]
2908 * srv_check_status: params[6]
2909 * srv_check_result: params[7]
2910 * srv_check_health: params[8]
2911 * srv_check_state: params[9]
2912 * srv_agent_state: params[10]
2913 * bk_f_forced_id: params[11]
2914 * srv_f_forced_id: params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002915 * srv_fqdn: params[13]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002916 */
2917
2918 /* validating srv_op_state */
2919 p = NULL;
2920 errno = 0;
2921 srv_op_state = strtol(params[1], &p, 10);
2922 if ((p == params[1]) || errno == EINVAL || errno == ERANGE ||
2923 (srv_op_state != SRV_ST_STOPPED &&
2924 srv_op_state != SRV_ST_STARTING &&
2925 srv_op_state != SRV_ST_RUNNING &&
2926 srv_op_state != SRV_ST_STOPPING)) {
2927 chunk_appendf(msg, ", invalid srv_op_state value '%s'", params[1]);
2928 }
2929
2930 /* validating srv_admin_state */
2931 p = NULL;
2932 errno = 0;
2933 srv_admin_state = strtol(params[2], &p, 10);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002934 fqdn_set_by_cli = !!(srv_admin_state & SRV_ADMF_HMAINT);
Willy Tarreau757478e2016-11-03 19:22:19 +01002935
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002936 /* inherited statuses will be recomputed later.
2937 * Also disable SRV_ADMF_HMAINT flag (set from stats socket fqdn).
2938 */
2939 srv_admin_state &= ~SRV_ADMF_IDRAIN & ~SRV_ADMF_IMAINT & ~SRV_ADMF_HMAINT;
Willy Tarreau757478e2016-11-03 19:22:19 +01002940
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002941 if ((p == params[2]) || errno == EINVAL || errno == ERANGE ||
2942 (srv_admin_state != 0 &&
2943 srv_admin_state != SRV_ADMF_FMAINT &&
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002944 srv_admin_state != SRV_ADMF_CMAINT &&
2945 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT) &&
Willy Tarreaue1bde142016-11-03 18:33:25 +01002946 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FDRAIN) &&
Willy Tarreau757478e2016-11-03 19:22:19 +01002947 srv_admin_state != SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002948 chunk_appendf(msg, ", invalid srv_admin_state value '%s'", params[2]);
2949 }
2950
2951 /* validating srv_uweight */
2952 p = NULL;
2953 errno = 0;
2954 srv_uweight = strtol(params[3], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002955 if ((p == params[3]) || errno == EINVAL || errno == ERANGE || (srv_uweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002956 chunk_appendf(msg, ", invalid srv_uweight value '%s'", params[3]);
2957
2958 /* validating srv_iweight */
2959 p = NULL;
2960 errno = 0;
2961 srv_iweight = strtol(params[4], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002962 if ((p == params[4]) || errno == EINVAL || errno == ERANGE || (srv_iweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002963 chunk_appendf(msg, ", invalid srv_iweight value '%s'", params[4]);
2964
2965 /* validating srv_last_time_change */
2966 p = NULL;
2967 errno = 0;
2968 srv_last_time_change = strtol(params[5], &p, 10);
2969 if ((p == params[5]) || errno == EINVAL || errno == ERANGE)
2970 chunk_appendf(msg, ", invalid srv_last_time_change value '%s'", params[5]);
2971
2972 /* validating srv_check_status */
2973 p = NULL;
2974 errno = 0;
2975 srv_check_status = strtol(params[6], &p, 10);
2976 if (p == params[6] || errno == EINVAL || errno == ERANGE ||
2977 (srv_check_status >= HCHK_STATUS_SIZE))
2978 chunk_appendf(msg, ", invalid srv_check_status value '%s'", params[6]);
2979
2980 /* validating srv_check_result */
2981 p = NULL;
2982 errno = 0;
2983 srv_check_result = strtol(params[7], &p, 10);
2984 if ((p == params[7]) || errno == EINVAL || errno == ERANGE ||
2985 (srv_check_result != CHK_RES_UNKNOWN &&
2986 srv_check_result != CHK_RES_NEUTRAL &&
2987 srv_check_result != CHK_RES_FAILED &&
2988 srv_check_result != CHK_RES_PASSED &&
2989 srv_check_result != CHK_RES_CONDPASS)) {
2990 chunk_appendf(msg, ", invalid srv_check_result value '%s'", params[7]);
2991 }
2992
2993 /* validating srv_check_health */
2994 p = NULL;
2995 errno = 0;
2996 srv_check_health = strtol(params[8], &p, 10);
2997 if (p == params[8] || errno == EINVAL || errno == ERANGE)
2998 chunk_appendf(msg, ", invalid srv_check_health value '%s'", params[8]);
2999
3000 /* validating srv_check_state */
3001 p = NULL;
3002 errno = 0;
3003 srv_check_state = strtol(params[9], &p, 10);
3004 if (p == params[9] || errno == EINVAL || errno == ERANGE ||
3005 (srv_check_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
3006 chunk_appendf(msg, ", invalid srv_check_state value '%s'", params[9]);
3007
3008 /* validating srv_agent_state */
3009 p = NULL;
3010 errno = 0;
3011 srv_agent_state = strtol(params[10], &p, 10);
3012 if (p == params[10] || errno == EINVAL || errno == ERANGE ||
3013 (srv_agent_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
3014 chunk_appendf(msg, ", invalid srv_agent_state value '%s'", params[10]);
3015
3016 /* validating bk_f_forced_id */
3017 p = NULL;
3018 errno = 0;
3019 bk_f_forced_id = strtol(params[11], &p, 10);
3020 if (p == params[11] || errno == EINVAL || errno == ERANGE || !((bk_f_forced_id == 0) || (bk_f_forced_id == 1)))
3021 chunk_appendf(msg, ", invalid bk_f_forced_id value '%s'", params[11]);
3022
3023 /* validating srv_f_forced_id */
3024 p = NULL;
3025 errno = 0;
3026 srv_f_forced_id = strtol(params[12], &p, 10);
3027 if (p == params[12] || errno == EINVAL || errno == ERANGE || !((srv_f_forced_id == 0) || (srv_f_forced_id == 1)))
3028 chunk_appendf(msg, ", invalid srv_f_forced_id value '%s'", params[12]);
3029
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003030 /* validating srv_fqdn */
3031 fqdn = params[13];
3032 if (fqdn && *fqdn == '-')
3033 fqdn = NULL;
3034 if (fqdn && (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn))) {
3035 chunk_appendf(msg, ", invalid srv_fqdn value '%s'", params[13]);
3036 fqdn = NULL;
3037 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003038
3039 /* don't apply anything if one error has been detected */
Willy Tarreau31138fa2015-09-29 18:38:47 +02003040 if (msg->len)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003041 goto out;
3042
3043 /* recover operational state and apply it to this server
3044 * and all servers tracking this one */
3045 switch (srv_op_state) {
3046 case SRV_ST_STOPPED:
3047 srv->check.health = 0;
3048 srv_set_stopped(srv, "changed from server-state after a reload");
3049 break;
3050 case SRV_ST_STARTING:
3051 srv->state = srv_op_state;
3052 break;
3053 case SRV_ST_STOPPING:
3054 srv->check.health = srv->check.rise + srv->check.fall - 1;
3055 srv_set_stopping(srv, "changed from server-state after a reload");
3056 break;
3057 case SRV_ST_RUNNING:
3058 srv->check.health = srv->check.rise + srv->check.fall - 1;
3059 srv_set_running(srv, "");
3060 break;
3061 }
3062
3063 /* When applying server state, the following rules apply:
3064 * - in case of a configuration change, we apply the setting from the new
3065 * configuration, regardless of old running state
3066 * - if no configuration change, we apply old running state only if old running
3067 * state is different from new configuration state
3068 */
3069 /* configuration has changed */
3070 if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->admin & SRV_ADMF_CMAINT)) {
3071 if (srv->admin & SRV_ADMF_CMAINT)
3072 srv_adm_set_maint(srv);
3073 else
3074 srv_adm_set_ready(srv);
3075 }
3076 /* configuration is the same, let's compate old running state and new conf state */
3077 else {
3078 if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->admin & SRV_ADMF_CMAINT))
3079 srv_adm_set_maint(srv);
3080 else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->admin & SRV_ADMF_CMAINT))
3081 srv_adm_set_ready(srv);
3082 }
3083 /* apply drain mode if server is currently enabled */
3084 if (!(srv->admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) {
3085 /* The SRV_ADMF_FDRAIN flag is inherited when srv->iweight is 0
Willy Tarreau22cace22016-11-03 18:19:49 +01003086 * (srv->iweight is the weight set up in configuration).
3087 * There are two possible reasons for FDRAIN to have been present :
3088 * - previous config weight was zero
3089 * - "set server b/s drain" was sent to the CLI
3090 *
3091 * In the first case, we simply want to drop this drain state
3092 * if the new weight is not zero anymore, meaning the administrator
3093 * has intentionally turned the weight back to a positive value to
3094 * enable the server again after an operation. In the second case,
3095 * the drain state was forced on the CLI regardless of the config's
3096 * weight so we don't want a change to the config weight to lose this
3097 * status. What this means is :
3098 * - if previous weight was 0 and new one is >0, drop the DRAIN state.
3099 * - if the previous weight was >0, keep it.
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003100 */
Willy Tarreau22cace22016-11-03 18:19:49 +01003101 if (srv_iweight > 0 || srv->iweight == 0)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003102 srv_adm_set_drain(srv);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003103 }
3104
3105 srv->last_change = date.tv_sec - srv_last_time_change;
3106 srv->check.status = srv_check_status;
3107 srv->check.result = srv_check_result;
3108 srv->check.health = srv_check_health;
3109
3110 /* Only case we want to apply is removing ENABLED flag which could have been
3111 * done by the "disable health" command over the stats socket
3112 */
3113 if ((srv->check.state & CHK_ST_CONFIGURED) &&
3114 (srv_check_state & CHK_ST_CONFIGURED) &&
3115 !(srv_check_state & CHK_ST_ENABLED))
3116 srv->check.state &= ~CHK_ST_ENABLED;
3117
3118 /* Only case we want to apply is removing ENABLED flag which could have been
3119 * done by the "disable agent" command over the stats socket
3120 */
3121 if ((srv->agent.state & CHK_ST_CONFIGURED) &&
3122 (srv_agent_state & CHK_ST_CONFIGURED) &&
3123 !(srv_agent_state & CHK_ST_ENABLED))
3124 srv->agent.state &= ~CHK_ST_ENABLED;
3125
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02003126 /* We want to apply the previous 'running' weight (srv_uweight) only if there
3127 * was no change in the configuration: both previous and new iweight are equals
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003128 *
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02003129 * It means that a configuration file change has precedence over a unix socket change
3130 * for server's weight
3131 *
3132 * by default, HAProxy applies the following weight when parsing the configuration
3133 * srv->uweight = srv->iweight
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003134 */
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02003135 if (srv_iweight == srv->iweight) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003136 srv->uweight = srv_uweight;
3137 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003138 server_recalc_eweight(srv);
3139
Willy Tarreaue5a60682016-11-09 14:54:53 +01003140 /* load server IP address */
3141 srv->lastaddr = strdup(params[0]);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003142
3143 if (fqdn && srv->hostname) {
3144 if (!strcmp(srv->hostname, fqdn)) {
3145 /* Here we reset the 'set from stats socket FQDN' flag
3146 * to support such transitions:
3147 * Let's say initial FQDN value is foo1 (in configuration file).
3148 * - FQDN changed from stats socket, from foo1 to foo2 value,
3149 * - FQDN changed again from file configuration (with the same previous value
3150 set from stats socket, from foo1 to foo2 value),
3151 * - reload for any other reason than a FQDN modification,
3152 * the configuration file FQDN matches the fqdn server state file value.
3153 * So we must reset the 'set from stats socket FQDN' flag to be consistent with
3154 * any futher FQDN modification.
3155 */
3156 srv->admin &= ~SRV_ADMF_HMAINT;
3157 }
3158 else {
3159 /* If the FDQN has been changed from stats socket,
3160 * apply fqdn state file value (which is the value set
3161 * from stats socket).
3162 */
3163 if (fqdn_set_by_cli) {
3164 srv_set_fqdn(srv, fqdn);
3165 srv->admin |= SRV_ADMF_HMAINT;
3166 }
3167 }
3168 }
3169
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003170 break;
3171 default:
3172 chunk_appendf(msg, ", version '%d' not supported", version);
3173 }
3174
3175 out:
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003176 if (msg->len) {
3177 chunk_appendf(msg, "\n");
Willy Tarreau31138fa2015-09-29 18:38:47 +02003178 Warning("server-state application failed for server '%s/%s'%s",
3179 srv->proxy->id, srv->id, msg->str);
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003180 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003181}
3182
3183/* This function parses all the proxies and only take care of the backends (since we're looking for server)
3184 * For each proxy, it does the following:
3185 * - opens its server state file (either one or local one)
3186 * - read whole file, line by line
3187 * - analyse each line to check if it matches our current backend:
3188 * - backend name matches
3189 * - backend id matches if id is forced and name doesn't match
3190 * - if the server pointed by the line is found, then state is applied
3191 *
3192 * If the running backend uuid or id differs from the state file, then HAProxy reports
3193 * a warning.
3194 */
3195void apply_server_state(void)
3196{
3197 char *cur, *end;
3198 char mybuf[SRV_STATE_LINE_MAXLEN];
3199 int mybuflen;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003200 char *params[SRV_STATE_FILE_MAX_FIELDS] = {0};
3201 char *srv_params[SRV_STATE_FILE_MAX_FIELDS] = {0};
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003202 int arg, srv_arg, version, diff;
3203 FILE *f;
3204 char *filepath;
3205 char globalfilepath[MAXPATHLEN + 1];
3206 char localfilepath[MAXPATHLEN + 1];
3207 int len, fileopenerr, globalfilepathlen, localfilepathlen;
3208 extern struct proxy *proxy;
3209 struct proxy *curproxy, *bk;
3210 struct server *srv;
3211
3212 globalfilepathlen = 0;
3213 /* create the globalfilepath variable */
3214 if (global.server_state_file) {
3215 /* absolute path or no base directory provided */
3216 if ((global.server_state_file[0] == '/') || (!global.server_state_base)) {
3217 len = strlen(global.server_state_file);
3218 if (len > MAXPATHLEN) {
3219 globalfilepathlen = 0;
3220 goto globalfileerror;
3221 }
3222 memcpy(globalfilepath, global.server_state_file, len);
3223 globalfilepath[len] = '\0';
3224 globalfilepathlen = len;
3225 }
3226 else if (global.server_state_base) {
3227 len = strlen(global.server_state_base);
3228 globalfilepathlen += len;
3229
3230 if (globalfilepathlen > MAXPATHLEN) {
3231 globalfilepathlen = 0;
3232 goto globalfileerror;
3233 }
3234 strncpy(globalfilepath, global.server_state_base, len);
3235 globalfilepath[globalfilepathlen] = 0;
3236
3237 /* append a slash if needed */
3238 if (!globalfilepathlen || globalfilepath[globalfilepathlen - 1] != '/') {
3239 if (globalfilepathlen + 1 > MAXPATHLEN) {
3240 globalfilepathlen = 0;
3241 goto globalfileerror;
3242 }
3243 globalfilepath[globalfilepathlen++] = '/';
3244 }
3245
3246 len = strlen(global.server_state_file);
3247 if (globalfilepathlen + len > MAXPATHLEN) {
3248 globalfilepathlen = 0;
3249 goto globalfileerror;
3250 }
3251 memcpy(globalfilepath + globalfilepathlen, global.server_state_file, len);
3252 globalfilepathlen += len;
3253 globalfilepath[globalfilepathlen++] = 0;
3254 }
3255 }
3256 globalfileerror:
3257 if (globalfilepathlen == 0)
3258 globalfilepath[0] = '\0';
3259
3260 /* read servers state from local file */
3261 for (curproxy = proxy; curproxy != NULL; curproxy = curproxy->next) {
3262 /* servers are only in backends */
3263 if (!(curproxy->cap & PR_CAP_BE))
3264 continue;
3265 fileopenerr = 0;
3266 filepath = NULL;
3267
3268 /* search server state file path and name */
3269 switch (curproxy->load_server_state_from_file) {
3270 /* read servers state from global file */
3271 case PR_SRV_STATE_FILE_GLOBAL:
3272 /* there was an error while generating global server state file path */
3273 if (globalfilepathlen == 0)
3274 continue;
3275 filepath = globalfilepath;
3276 fileopenerr = 1;
3277 break;
3278 /* this backend has its own file */
3279 case PR_SRV_STATE_FILE_LOCAL:
3280 localfilepathlen = 0;
3281 localfilepath[0] = '\0';
3282 len = 0;
3283 /* create the localfilepath variable */
3284 /* absolute path or no base directory provided */
3285 if ((curproxy->server_state_file_name[0] == '/') || (!global.server_state_base)) {
3286 len = strlen(curproxy->server_state_file_name);
3287 if (len > MAXPATHLEN) {
3288 localfilepathlen = 0;
3289 goto localfileerror;
3290 }
3291 memcpy(localfilepath, curproxy->server_state_file_name, len);
3292 localfilepath[len] = '\0';
3293 localfilepathlen = len;
3294 }
3295 else if (global.server_state_base) {
3296 len = strlen(global.server_state_base);
3297 localfilepathlen += len;
3298
3299 if (localfilepathlen > MAXPATHLEN) {
3300 localfilepathlen = 0;
3301 goto localfileerror;
3302 }
3303 strncpy(localfilepath, global.server_state_base, len);
3304 localfilepath[localfilepathlen] = 0;
3305
3306 /* append a slash if needed */
3307 if (!localfilepathlen || localfilepath[localfilepathlen - 1] != '/') {
3308 if (localfilepathlen + 1 > MAXPATHLEN) {
3309 localfilepathlen = 0;
3310 goto localfileerror;
3311 }
3312 localfilepath[localfilepathlen++] = '/';
3313 }
3314
3315 len = strlen(curproxy->server_state_file_name);
3316 if (localfilepathlen + len > MAXPATHLEN) {
3317 localfilepathlen = 0;
3318 goto localfileerror;
3319 }
3320 memcpy(localfilepath + localfilepathlen, curproxy->server_state_file_name, len);
3321 localfilepathlen += len;
3322 localfilepath[localfilepathlen++] = 0;
3323 }
3324 filepath = localfilepath;
3325 localfileerror:
3326 if (localfilepathlen == 0)
3327 localfilepath[0] = '\0';
3328
3329 break;
3330 case PR_SRV_STATE_FILE_NONE:
3331 default:
3332 continue;
3333 }
3334
3335 /* preload global state file */
3336 errno = 0;
3337 f = fopen(filepath, "r");
3338 if (errno && fileopenerr)
3339 Warning("Can't open server state file '%s': %s\n", filepath, strerror(errno));
3340 if (!f)
3341 continue;
3342
3343 mybuf[0] = '\0';
3344 mybuflen = 0;
3345 version = 0;
3346
3347 /* first character of first line of the file must contain the version of the export */
Dragan Dosencf4fb032015-11-04 23:03:26 +01003348 if (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f) == NULL) {
3349 Warning("Can't read first line of the server state file '%s'\n", filepath);
3350 goto fileclose;
3351 }
3352
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003353 cur = mybuf;
3354 version = atoi(cur);
3355 if ((version < SRV_STATE_FILE_VERSION_MIN) ||
3356 (version > SRV_STATE_FILE_VERSION_MAX))
Dragan Dosencf4fb032015-11-04 23:03:26 +01003357 goto fileclose;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003358
3359 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3360 int bk_f_forced_id = 0;
3361 int check_id = 0;
3362 int check_name = 0;
3363
3364 mybuflen = strlen(mybuf);
3365 cur = mybuf;
3366 end = cur + mybuflen;
3367
3368 bk = NULL;
3369 srv = NULL;
3370
3371 /* we need at least one character */
3372 if (mybuflen == 0)
3373 continue;
3374
3375 /* ignore blank characters at the beginning of the line */
3376 while (isspace(*cur))
3377 ++cur;
3378
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003379 /* Ignore empty or commented lines */
3380 if (cur == end || *cur == '#')
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003381 continue;
3382
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003383 /* truncated lines */
3384 if (mybuf[mybuflen - 1] != '\n') {
3385 Warning("server-state file '%s': truncated line\n", filepath);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003386 continue;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003387 }
3388
3389 /* Removes trailing '\n' */
3390 mybuf[mybuflen - 1] = '\0';
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003391
3392 /* we're now ready to move the line into *srv_params[] */
3393 params[0] = cur;
3394 arg = 1;
3395 srv_arg = 0;
3396 while (*cur && arg < SRV_STATE_FILE_MAX_FIELDS) {
3397 if (isspace(*cur)) {
3398 *cur = '\0';
3399 ++cur;
3400 while (isspace(*cur))
3401 ++cur;
3402 switch (version) {
3403 case 1:
3404 /*
3405 * srv_addr: params[4] => srv_params[0]
3406 * srv_op_state: params[5] => srv_params[1]
3407 * srv_admin_state: params[6] => srv_params[2]
3408 * srv_uweight: params[7] => srv_params[3]
3409 * srv_iweight: params[8] => srv_params[4]
3410 * srv_last_time_change: params[9] => srv_params[5]
3411 * srv_check_status: params[10] => srv_params[6]
3412 * srv_check_result: params[11] => srv_params[7]
3413 * srv_check_health: params[12] => srv_params[8]
3414 * srv_check_state: params[13] => srv_params[9]
3415 * srv_agent_state: params[14] => srv_params[10]
3416 * bk_f_forced_id: params[15] => srv_params[11]
3417 * srv_f_forced_id: params[16] => srv_params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003418 * srv_fqdn: params[17] => srv_params[13]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003419 */
3420 if (arg >= 4) {
3421 srv_params[srv_arg] = cur;
3422 ++srv_arg;
3423 }
3424 break;
3425 }
3426
3427 params[arg] = cur;
3428 ++arg;
3429 }
3430 else {
3431 ++cur;
3432 }
3433 }
3434
3435 /* if line is incomplete line, then ignore it.
3436 * otherwise, update useful flags */
3437 switch (version) {
3438 case 1:
3439 if (arg < SRV_STATE_FILE_NB_FIELDS_VERSION_1)
3440 continue;
3441 bk_f_forced_id = (atoi(params[15]) & PR_O_FORCED_ID);
3442 check_id = (atoi(params[0]) == curproxy->uuid);
3443 check_name = (strcmp(curproxy->id, params[1]) == 0);
3444 break;
3445 }
3446
3447 diff = 0;
3448 bk = curproxy;
3449
3450 /* if backend can't be found, let's continue */
3451 if (!check_id && !check_name)
3452 continue;
3453 else if (!check_id && check_name) {
3454 Warning("backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3455 send_log(bk, LOG_NOTICE, "backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3456 }
3457 else if (check_id && !check_name) {
3458 Warning("backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3459 send_log(bk, LOG_NOTICE, "backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3460 /* if name doesn't match, we still want to update curproxy if the backend id
3461 * was forced in previous the previous configuration */
3462 if (!bk_f_forced_id)
3463 continue;
3464 }
3465
3466 /* look for the server by its id: param[2] */
3467 /* else look for the server by its name: param[3] */
3468 diff = 0;
3469 srv = server_find_best_match(bk, params[3], atoi(params[2]), &diff);
3470
3471 if (!srv) {
3472 /* if no server found, then warning and continue with next line */
3473 Warning("can't find server '%s' with id '%s' in backend with id '%s' or name '%s'\n",
3474 params[3], params[2], params[0], params[1]);
3475 send_log(bk, LOG_NOTICE, "can't find server '%s' with id '%s' in backend with id '%s' or name '%s'\n",
3476 params[3], params[2], params[0], params[1]);
3477 continue;
3478 }
3479 else if (diff & PR_FBM_MISMATCH_ID) {
3480 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);
3481 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 +02003482 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003483 }
3484 else if (diff & PR_FBM_MISMATCH_NAME) {
3485 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);
3486 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 +02003487 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003488 }
3489
3490 /* now we can proceed with server's state update */
3491 srv_update_state(srv, version, srv_params);
3492 }
Dragan Dosencf4fb032015-11-04 23:03:26 +01003493fileclose:
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003494 fclose(f);
3495 }
3496}
3497
Simon Horman7d09b9a2013-02-12 10:45:51 +09003498/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02003499 * update a server's current IP address.
3500 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
3501 * ip is in network format.
3502 * updater is a string which contains an information about the requester of the update.
3503 * updater is used if not NULL.
3504 *
3505 * A log line and a stderr warning message is generated based on server's backend options.
3506 */
Thierry Fournierd35b7a62016-02-24 08:23:22 +01003507int update_server_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02003508{
3509 /* generates a log line and a warning on stderr */
3510 if (1) {
3511 /* book enough space for both IPv4 and IPv6 */
3512 char oldip[INET6_ADDRSTRLEN];
3513 char newip[INET6_ADDRSTRLEN];
3514
3515 memset(oldip, '\0', INET6_ADDRSTRLEN);
3516 memset(newip, '\0', INET6_ADDRSTRLEN);
3517
3518 /* copy old IP address in a string */
3519 switch (s->addr.ss_family) {
3520 case AF_INET:
3521 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
3522 break;
3523 case AF_INET6:
3524 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
3525 break;
3526 };
3527
3528 /* copy new IP address in a string */
3529 switch (ip_sin_family) {
3530 case AF_INET:
3531 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
3532 break;
3533 case AF_INET6:
3534 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
3535 break;
3536 };
3537
3538 /* save log line into a buffer */
3539 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
3540 s->proxy->id, s->id, oldip, newip, updater);
3541
3542 /* write the buffer on stderr */
3543 Warning("%s.\n", trash.str);
3544
3545 /* send a log */
3546 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
3547 }
3548
3549 /* save the new IP family */
3550 s->addr.ss_family = ip_sin_family;
3551 /* save the new IP address */
3552 switch (ip_sin_family) {
3553 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02003554 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003555 break;
3556 case AF_INET6:
3557 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
3558 break;
3559 };
Olivier Houchard4e694042017-03-14 20:01:29 +01003560 srv_set_dyncookie(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003561
3562 return 0;
3563}
3564
3565/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003566 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3567 *
3568 * Caller can pass its name through <updater> to get it integrated in the response message
3569 * returned by the function.
3570 *
3571 * The function first does the following, in that order:
3572 * - validates the new addr and/or port
3573 * - checks if an update is required (new IP or port is different than current ones)
3574 * - checks the update is allowed:
3575 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3576 * - allow all changes if no CHECKS are configured
3577 * - if CHECK is configured:
3578 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3579 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3580 * conditions are met
3581 */
3582const char *update_server_addr_port(struct server *s, const char *addr, const char *port, char *updater)
3583{
3584 struct sockaddr_storage sa;
3585 int ret, port_change_required;
3586 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003587 uint16_t current_port, new_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003588 struct chunk *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003589 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003590
3591 msg = get_trash_chunk();
3592 chunk_reset(msg);
3593
3594 if (addr) {
3595 memset(&sa, 0, sizeof(struct sockaddr_storage));
3596 if (str2ip2(addr, &sa, 0) == NULL) {
3597 chunk_printf(msg, "Invalid addr '%s'", addr);
3598 goto out;
3599 }
3600
3601 /* changes are allowed on AF_INET* families only */
3602 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3603 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3604 goto out;
3605 }
3606
3607 /* collecting data currently setup */
3608 memset(current_addr, '\0', sizeof(current_addr));
3609 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3610 /* changes are allowed on AF_INET* families only */
3611 if ((ret != AF_INET) && (ret != AF_INET6)) {
3612 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3613 goto out;
3614 }
3615
3616 /* applying ADDR changes if required and allowed
3617 * ipcmp returns 0 when both ADDR are the same
3618 */
3619 if (ipcmp(&s->addr, &sa) == 0) {
3620 chunk_appendf(msg, "no need to change the addr");
3621 goto port;
3622 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003623 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003624 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003625
3626 /* we also need to update check's ADDR only if it uses the server's one */
3627 if ((s->check.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_CHECKADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003628 ipcpy(&sa, &s->check.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003629 }
3630
3631 /* we also need to update agent ADDR only if it use the server's one */
3632 if ((s->agent.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_AGENTADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003633 ipcpy(&sa, &s->agent.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003634 }
3635
3636 /* update report for caller */
3637 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3638 }
3639
3640 port:
3641 if (port) {
3642 char sign = '\0';
3643 char *endptr;
3644
3645 if (addr)
3646 chunk_appendf(msg, ", ");
3647
3648 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003649 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003650
3651 /* check if PORT change is required */
3652 port_change_required = 0;
3653
3654 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003655 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003656 new_port = strtol(port, &endptr, 10);
3657 if ((errno != 0) || (port == endptr)) {
3658 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3659 goto out;
3660 }
3661
3662 /* check if caller triggers a port mapped or offset */
3663 if (sign == '-' || (sign == '+')) {
3664 /* check if server currently uses port map */
3665 if (!(s->flags & SRV_F_MAPPORTS)) {
3666 /* switch from fixed port to port map mandatorily triggers
3667 * a port change */
3668 port_change_required = 1;
3669 /* check is configured
3670 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3671 * prevent PORT change if check doesn't have it's dedicated port while switching
3672 * to port mapping */
3673 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3674 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.");
3675 goto out;
3676 }
3677 }
3678 /* we're already using port maps */
3679 else {
3680 port_change_required = current_port != new_port;
3681 }
3682 }
3683 /* fixed port */
3684 else {
3685 port_change_required = current_port != new_port;
3686 }
3687
3688 /* applying PORT changes if required and update response message */
3689 if (port_change_required) {
3690 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003691 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003692 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003693
3694 /* prepare message */
3695 chunk_appendf(msg, "port changed from '");
3696 if (s->flags & SRV_F_MAPPORTS)
3697 chunk_appendf(msg, "+");
3698 chunk_appendf(msg, "%d' to '", current_port);
3699
3700 if (sign == '-') {
3701 s->flags |= SRV_F_MAPPORTS;
3702 chunk_appendf(msg, "%c", sign);
3703 /* just use for result output */
3704 new_port = -new_port;
3705 }
3706 else if (sign == '+') {
3707 s->flags |= SRV_F_MAPPORTS;
3708 chunk_appendf(msg, "%c", sign);
3709 }
3710 else {
3711 s->flags &= ~SRV_F_MAPPORTS;
3712 }
3713
3714 chunk_appendf(msg, "%d'", new_port);
3715
3716 /* we also need to update health checks port only if it uses server's realport */
3717 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3718 s->check.port = new_port;
3719 }
3720 }
3721 else {
3722 chunk_appendf(msg, "no need to change the port");
3723 }
3724 }
3725
3726out:
Olivier Houchard4e694042017-03-14 20:01:29 +01003727 if (changed)
3728 srv_set_dyncookie(s);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003729 if (updater)
3730 chunk_appendf(msg, " by '%s'", updater);
3731 chunk_appendf(msg, "\n");
3732 return msg->str;
3733}
3734
3735
3736/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003737 * update server status based on result of name resolution
3738 * returns:
3739 * 0 if server status is updated
3740 * 1 if server status has not changed
3741 */
3742int snr_update_srv_status(struct server *s)
3743{
3744 struct dns_resolution *resolution = s->resolution;
Baptiste Assmann42746372017-05-03 12:12:02 +02003745 struct dns_resolvers *resolvers = s->resolvers;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003746
3747 switch (resolution->status) {
3748 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003749 /* status when HAProxy has just (re)started.
3750 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003751 break;
3752
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003753 case RSLV_STATUS_VALID:
3754 /*
3755 * resume health checks
3756 * server will be turned back on if health check is safe
3757 */
3758 if (!(s->admin & SRV_ADMF_RMAINT))
3759 return 1;
3760 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3761 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3762 s->proxy->id, s->id);
3763
3764 Warning("%s.\n", trash.str);
3765 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
3766 return 0;
3767
3768 case RSLV_STATUS_NX:
3769 /* stop server if resolution is NX for a long enough period */
3770 if (tick_is_expired(tick_add(resolution->last_status_change, resolvers->hold.nx), now_ms)) {
3771 if (s->admin & SRV_ADMF_RMAINT)
3772 return 1;
3773 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3774 return 0;
3775 }
3776 break;
3777
3778 case RSLV_STATUS_TIMEOUT:
3779 /* stop server if resolution is TIMEOUT for a long enough period */
3780 if (tick_is_expired(tick_add(resolution->last_status_change, resolvers->hold.timeout), now_ms)) {
3781 if (s->admin & SRV_ADMF_RMAINT)
3782 return 1;
3783 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3784 return 0;
3785 }
3786 break;
3787
3788 case RSLV_STATUS_REFUSED:
3789 /* stop server if resolution is REFUSED for a long enough period */
3790 if (tick_is_expired(tick_add(resolution->last_status_change, resolvers->hold.refused), now_ms)) {
3791 if (s->admin & SRV_ADMF_RMAINT)
3792 return 1;
3793 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3794 return 0;
3795 }
3796 break;
3797
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003798 default:
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003799 /* stop server if resolution is in unmatched error for a long enough period */
3800 if (tick_is_expired(tick_add(resolution->last_status_change, resolvers->hold.other), now_ms)) {
3801 if (s->admin & SRV_ADMF_RMAINT)
3802 return 1;
3803 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3804 return 0;
3805 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003806 break;
3807 }
3808
3809 return 1;
3810}
3811
3812/*
3813 * Server Name Resolution valid response callback
3814 * It expects:
3815 * - <nameserver>: the name server which answered the valid response
3816 * - <response>: buffer containing a valid DNS response
3817 * - <response_len>: size of <response>
3818 * It performs the following actions:
3819 * - ignore response if current ip found and server family not met
3820 * - update with first new ip found if family is met and current IP is not found
3821 * returns:
3822 * 0 on error
3823 * 1 when no error or safe ignore
3824 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003825int snr_resolution_cb(struct dns_requester *requester, struct dns_nameserver *nameserver)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003826{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003827 struct server *s = NULL;
3828 struct dns_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003829 void *serverip, *firstip;
3830 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003831 int ret;
3832 struct chunk *chk = get_trash_chunk();
3833
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003834 s = objt_server(requester->requester);
3835 if (!s)
3836 return 1;
3837
3838 resolution = s->resolution;
3839
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003840 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003841 firstip = NULL; /* pointer to the first valid response found */
3842 /* it will be used as the new IP if a change is required */
3843 firstip_sin_family = AF_UNSPEC;
3844 serverip = NULL; /* current server IP address */
3845
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003846 /* initializing server IP pointer */
3847 server_sin_family = s->addr.ss_family;
3848 switch (server_sin_family) {
3849 case AF_INET:
3850 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3851 break;
3852
3853 case AF_INET6:
3854 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3855 break;
3856
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003857 case AF_UNSPEC:
3858 break;
3859
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003860 default:
3861 goto invalid;
3862 }
3863
Baptiste Assmann729c9012017-05-22 15:13:10 +02003864 ret = dns_get_ip_from_response(&resolution->response, &s->dns_opts,
Thierry Fournierada34842016-02-17 21:25:09 +01003865 serverip, server_sin_family, &firstip,
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003866 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003867
3868 switch (ret) {
3869 case DNS_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003870 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003871
3872 case DNS_UPD_SRVIP_NOT_FOUND:
3873 goto save_ip;
3874
3875 case DNS_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003876 goto invalid;
3877
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003878 case DNS_UPD_NO_IP_FOUND:
3879 if (resolution->status != RSLV_STATUS_OTHER) {
3880 resolution->status = RSLV_STATUS_OTHER;
3881 resolution->last_status_change = now_ms;
3882 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003883 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003884
Baptiste Assmannfad03182015-10-28 02:03:32 +01003885 case DNS_UPD_NAME_ERROR:
3886 /* if this is not the last expected response, we ignore it */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003887 if (nameserver && (resolution->nb_responses < nameserver->resolvers->count_nameservers))
Baptiste Assmannfad03182015-10-28 02:03:32 +01003888 return 0;
3889 /* update resolution status to OTHER error type */
3890 if (resolution->status != RSLV_STATUS_OTHER) {
3891 resolution->status = RSLV_STATUS_OTHER;
3892 resolution->last_status_change = now_ms;
3893 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003894 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003895
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003896 default:
3897 goto invalid;
3898
3899 }
3900
3901 save_ip:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003902 if (nameserver)
3903 nameserver->counters.update += 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003904
3905 /* save the first ip we found */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003906 if (nameserver)
3907 chunk_printf(chk, "%s/%s", nameserver->resolvers->id, nameserver->id);
3908 else
3909 chunk_printf(chk, "DNS cache");
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003910 update_server_addr(s, firstip, firstip_sin_family, (char *)chk->str);
3911
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003912 update_status:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003913 snr_update_srv_status(s);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003914 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003915
3916 invalid:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003917 if (nameserver)
3918 nameserver->counters.invalid += 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003919 if (resolution->nb_responses >= nameserver->resolvers->count_nameservers)
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003920 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003921
3922 snr_update_srv_status(s);
3923 return 0;
3924}
3925
3926/*
3927 * Server Name Resolution error management callback
3928 * returns:
3929 * 0 on error
3930 * 1 when no error or safe ignore
3931 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003932int snr_resolution_error_cb(struct dns_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003933{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003934 struct server *s = NULL;
3935 struct dns_resolution *resolution = NULL;
3936 struct dns_resolvers *resolvers = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003937
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003938 s = objt_server(requester->requester);
3939 if (!s)
3940 return 1;
3941
3942 resolution = s->resolution;
Baptiste Assmann42746372017-05-03 12:12:02 +02003943 resolvers = s->resolvers;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003944
3945 /* can be ignored if this is not the last response */
3946 if ((error_code != DNS_RESP_TIMEOUT) && (resolution->nb_responses < resolvers->count_nameservers)) {
3947 return 1;
3948 }
3949
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003950 snr_update_srv_status(s);
3951 return 1;
3952}
3953
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003954/*
3955 * Function to check if <ip> is already affected to a server in the backend
3956 * which owns <srv>.
3957 * It returns a pointer to the first server found or NULL if <ip> is not yet
3958 * assigned.
3959 * NOTE: <ip> and <ip_family> are provided by a 'struct rec' available in dns.c.
3960 */
3961struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3962{
3963 struct server *tmpsrv;
3964 struct proxy *be;
3965
3966 if (!srv)
3967 return NULL;
3968
3969 be = srv->proxy;
3970 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
3971 /* We want to compare the IP in the record with the IP of the servers in the
3972 * same backend, only if:
3973 * * DNS resolution is enabled on the server
3974 * * the hostname used for the resolution by our server is the same than the
3975 * one used for the server found in the backend
3976 * * the server found in the backend is not our current server
3977 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003978 if ((tmpsrv->hostname_dn == NULL) ||
3979 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
3980 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003981 (srv->puid == tmpsrv->puid))
3982 continue;
3983
3984 /* At this point, we have 2 different servers using the same DNS hostname
3985 * for their respective resolution.
3986 */
3987 if (*ip_family == tmpsrv->addr.ss_family &&
3988 ((tmpsrv->addr.ss_family == AF_INET &&
3989 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3990 (tmpsrv->addr.ss_family == AF_INET6 &&
3991 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
3992 return tmpsrv;
3993 }
3994 }
3995
3996 return NULL;
3997}
3998
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003999/* Sets the server's address (srv->addr) from srv->hostname using the libc's
4000 * resolver. This is suited for initial address configuration. Returns 0 on
4001 * success otherwise a non-zero error code. In case of error, *err_code, if
4002 * not NULL, is filled up.
4003 */
4004int srv_set_addr_via_libc(struct server *srv, int *err_code)
4005{
4006 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004007 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01004008 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004009 return 1;
4010 }
4011 return 0;
4012}
4013
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004014/* Set the server's FDQN (->hostname) from <hostname>.
4015 * Returns -1 if failed, 0 if not.
4016 */
4017int srv_set_fqdn(struct server *srv, const char *hostname)
4018{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004019 struct dns_resolution *resolution;
4020 int hostname_dn_len;
4021
4022 /* run time DNS resolution was not active for this server
4023 * and we can't enable it at run time for now.
4024 */
4025 if (!srv->dns_requester)
4026 return -1;
4027
4028 chunk_reset(&trash);
4029
4030 /* check if hostname is really a hostname and if we have enough
4031 * room to save it in its domain name format
4032 */
4033 hostname_dn_len = dns_str_to_dn_label_len(hostname);
4034 if (hostname_dn_len == -1 || hostname_dn_len + 1 > trash.size)
4035 return -1;
4036
4037 if (!dns_str_to_dn_label(hostname,
4038 trash.str,
4039 hostname_dn_len + 1))
4040 return -1;
4041
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004042
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004043 /* get a resolution from the curr or wait queues, or a brand new one from the pool */
4044 resolution = dns_resolution_list_get(srv->resolvers, trash.str, srv->dns_requester->prefered_query_type);
4045 if (!resolution)
4046 return -1;
4047
4048 /* in this case, the new hostanme is the same than the old one */
4049 if (srv->resolution == resolution)
4050 return 0;
4051
4052 /* first, we need to unlink our server from its current resolution */
4053 srv_free_from_resolution(srv);
4054
4055 /* now we update server's parameters */
4056 free(srv->hostname);
4057 free(srv->hostname_dn);
4058 srv->hostname = strdup(hostname);
4059 srv->hostname_dn = strdup(trash.str);
4060 srv->hostname_dn_len = hostname_dn_len;
4061 if (!srv->hostname || !srv->hostname_dn)
4062 return -1;
4063
4064 /* then we can link srv to its new resolution */
4065 dns_link_resolution(srv, OBJ_TYPE_SERVER, resolution);
4066
4067 return 0;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004068}
4069
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004070/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
4071 * from the state file. This is suited for initial address configuration.
4072 * Returns 0 on success otherwise a non-zero error code. In case of error,
4073 * *err_code, if not NULL, is filled up.
4074 */
4075static int srv_apply_lastaddr(struct server *srv, int *err_code)
4076{
4077 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
4078 if (err_code)
4079 *err_code |= ERR_WARN;
4080 return 1;
4081 }
4082 return 0;
4083}
4084
Willy Tarreau25e51522016-11-04 15:10:17 +01004085/* returns 0 if no error, otherwise a combination of ERR_* flags */
4086static int srv_iterate_initaddr(struct server *srv)
4087{
4088 int return_code = 0;
4089 int err_code;
4090 unsigned int methods;
4091
4092 methods = srv->init_addr_methods;
4093 if (!methods) { // default to "last,libc"
4094 srv_append_initaddr(&methods, SRV_IADDR_LAST);
4095 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
4096 }
4097
Willy Tarreau3eed10e2016-11-07 21:03:16 +01004098 /* "-dr" : always append "none" so that server addresses resolution
4099 * failures are silently ignored, this is convenient to validate some
4100 * configs out of their environment.
4101 */
4102 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
4103 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4104
Willy Tarreau25e51522016-11-04 15:10:17 +01004105 while (methods) {
4106 err_code = 0;
4107 switch (srv_get_next_initaddr(&methods)) {
4108 case SRV_IADDR_LAST:
4109 if (!srv->lastaddr)
4110 continue;
4111 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004112 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004113 return_code |= err_code;
4114 break;
4115
4116 case SRV_IADDR_LIBC:
4117 if (!srv->hostname)
4118 continue;
4119 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004120 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004121 return_code |= err_code;
4122 break;
4123
Willy Tarreau37ebe122016-11-04 15:17:58 +01004124 case SRV_IADDR_NONE:
4125 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004126 if (return_code) {
4127 Warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
4128 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
4129 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01004130 return return_code;
4131
Willy Tarreau4310d362016-11-02 15:05:56 +01004132 case SRV_IADDR_IP:
4133 ipcpy(&srv->init_addr, &srv->addr);
4134 if (return_code) {
4135 Warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', falling back to configured address.\n",
4136 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
4137 }
Olivier Houchard4e694042017-03-14 20:01:29 +01004138 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01004139
Willy Tarreau25e51522016-11-04 15:10:17 +01004140 default: /* unhandled method */
4141 break;
4142 }
4143 }
4144
4145 if (!return_code) {
4146 Alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
4147 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
4148 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01004149 else {
4150 Alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
4151 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
4152 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004153
4154 return_code |= ERR_ALERT | ERR_FATAL;
4155 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01004156out:
4157 srv_set_dyncookie(srv);
4158 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01004159}
4160
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004161/*
4162 * This function parses all backends and all servers within each backend
4163 * and performs servers' addr resolution based on information provided by:
4164 * - configuration file
4165 * - server-state file (states provided by an 'old' haproxy process)
4166 *
4167 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
4168 */
4169int srv_init_addr(void)
4170{
4171 struct proxy *curproxy;
4172 int return_code = 0;
4173
4174 curproxy = proxy;
4175 while (curproxy) {
4176 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004177
4178 /* servers are in backend only */
4179 if (!(curproxy->cap & PR_CAP_BE))
4180 goto srv_init_addr_next;
4181
Willy Tarreau25e51522016-11-04 15:10:17 +01004182 for (srv = curproxy->srv; srv; srv = srv->next)
4183 if (srv->hostname)
4184 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004185
4186 srv_init_addr_next:
4187 curproxy = curproxy->next;
4188 }
4189
4190 return return_code;
4191}
4192
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004193const char *update_server_fqdn(struct server *server, const char *fqdn, const char *updater)
4194{
4195
4196 struct chunk *msg;
4197
4198 msg = get_trash_chunk();
4199 chunk_reset(msg);
4200
4201 if (!strcmp(fqdn, server->hostname)) {
4202 chunk_appendf(msg, "no need to change the FDQN");
4203 goto out;
4204 }
4205
4206 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
4207 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
4208 goto out;
4209 }
4210
4211 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
4212 server->proxy->id, server->id, server->hostname, fqdn);
4213
4214 if (srv_set_fqdn(server, fqdn) < 0) {
4215 chunk_reset(msg);
4216 chunk_appendf(msg, "could not update %s/%s FQDN",
4217 server->proxy->id, server->id);
4218 goto out;
4219 }
4220
4221 /* Flag as FQDN set from stats socket. */
4222 server->admin |= SRV_ADMF_HMAINT;
4223
4224 out:
4225 if (updater)
4226 chunk_appendf(msg, " by '%s'", updater);
4227 chunk_appendf(msg, "\n");
4228
4229 return msg->str;
4230}
4231
4232
Willy Tarreau21b069d2016-11-23 17:15:08 +01004233/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
4234 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004235 * 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 +01004236 * used for CLI commands requiring a server name.
4237 * Important: the <arg> is modified to remove the '/'.
4238 */
4239struct server *cli_find_server(struct appctx *appctx, char *arg)
4240{
4241 struct proxy *px;
4242 struct server *sv;
4243 char *line;
4244
4245 /* split "backend/server" and make <line> point to server */
4246 for (line = arg; *line; line++)
4247 if (*line == '/') {
4248 *line++ = '\0';
4249 break;
4250 }
4251
4252 if (!*line || !*arg) {
4253 appctx->ctx.cli.msg = "Require 'backend/server'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004254 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004255 return NULL;
4256 }
4257
4258 if (!get_backend_server(arg, line, &px, &sv)) {
4259 appctx->ctx.cli.msg = px ? "No such server.\n" : "No such backend.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004260 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004261 return NULL;
4262 }
4263
4264 if (px->state == PR_STSTOPPED) {
4265 appctx->ctx.cli.msg = "Proxy is disabled.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004266 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004267 return NULL;
4268 }
4269
4270 return sv;
4271}
4272
William Lallemand222baf22016-11-19 02:00:33 +01004273
4274static int cli_parse_set_server(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 if (strcmp(args[3], "weight") == 0) {
4287 warning = server_parse_weight_change_request(sv, args[4]);
4288 if (warning) {
4289 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004290 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004291 }
4292 }
4293 else if (strcmp(args[3], "state") == 0) {
4294 if (strcmp(args[4], "ready") == 0)
4295 srv_adm_set_ready(sv);
4296 else if (strcmp(args[4], "drain") == 0)
4297 srv_adm_set_drain(sv);
4298 else if (strcmp(args[4], "maint") == 0)
4299 srv_adm_set_maint(sv);
4300 else {
4301 appctx->ctx.cli.msg = "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004302 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004303 }
4304 }
4305 else if (strcmp(args[3], "health") == 0) {
4306 if (sv->track) {
4307 appctx->ctx.cli.msg = "cannot change health on a tracking server.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004308 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004309 }
4310 else if (strcmp(args[4], "up") == 0) {
4311 sv->check.health = sv->check.rise + sv->check.fall - 1;
4312 srv_set_running(sv, "changed from CLI");
4313 }
4314 else if (strcmp(args[4], "stopping") == 0) {
4315 sv->check.health = sv->check.rise + sv->check.fall - 1;
4316 srv_set_stopping(sv, "changed from CLI");
4317 }
4318 else if (strcmp(args[4], "down") == 0) {
4319 sv->check.health = 0;
4320 srv_set_stopped(sv, "changed from CLI");
4321 }
4322 else {
4323 appctx->ctx.cli.msg = "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004324 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004325 }
4326 }
4327 else if (strcmp(args[3], "agent") == 0) {
4328 if (!(sv->agent.state & CHK_ST_ENABLED)) {
4329 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004330 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004331 }
4332 else if (strcmp(args[4], "up") == 0) {
4333 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
4334 srv_set_running(sv, "changed from CLI");
4335 }
4336 else if (strcmp(args[4], "down") == 0) {
4337 sv->agent.health = 0;
4338 srv_set_stopped(sv, "changed from CLI");
4339 }
4340 else {
4341 appctx->ctx.cli.msg = "'set server <srv> agent' expects 'up' or 'down'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004342 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004343 }
4344 }
Misiek2da082d2017-01-09 09:40:42 +01004345 else if (strcmp(args[3], "agent-addr") == 0) {
4346 if (!(sv->agent.state & CHK_ST_ENABLED)) {
4347 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
4348 appctx->st0 = CLI_ST_PRINT;
4349 } else {
4350 if (str2ip(args[4], &sv->agent.addr) == NULL) {
4351 appctx->ctx.cli.msg = "incorrect addr address given for agent.\n";
4352 appctx->st0 = CLI_ST_PRINT;
4353 }
4354 }
4355 }
4356 else if (strcmp(args[3], "agent-send") == 0) {
4357 if (!(sv->agent.state & CHK_ST_ENABLED)) {
4358 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
4359 appctx->st0 = CLI_ST_PRINT;
4360 } else {
4361 char *nss = strdup(args[4]);
4362 if (!nss) {
4363 appctx->ctx.cli.msg = "cannot allocate memory for new string.\n";
4364 appctx->st0 = CLI_ST_PRINT;
4365 } else {
4366 free(sv->agent.send_string);
4367 sv->agent.send_string = nss;
4368 sv->agent.send_string_len = strlen(args[4]);
4369 }
4370 }
4371 }
William Lallemand222baf22016-11-19 02:00:33 +01004372 else if (strcmp(args[3], "check-port") == 0) {
4373 int i = 0;
4374 if (strl2irc(args[4], strlen(args[4]), &i) != 0) {
4375 appctx->ctx.cli.msg = "'set server <srv> check-port' expects an integer as argument.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004376 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004377 }
4378 if ((i < 0) || (i > 65535)) {
4379 appctx->ctx.cli.msg = "provided port is not valid.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004380 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004381 }
4382 /* prevent the update of port to 0 if MAPPORTS are in use */
4383 if ((sv->flags & SRV_F_MAPPORTS) && (i == 0)) {
4384 appctx->ctx.cli.msg = "can't unset 'port' since MAPPORTS is in use.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004385 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004386 return 1;
4387 }
4388 sv->check.port = i;
4389 appctx->ctx.cli.msg = "health check port updated.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004390 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004391 }
4392 else if (strcmp(args[3], "addr") == 0) {
4393 char *addr = NULL;
4394 char *port = NULL;
4395 if (strlen(args[4]) == 0) {
4396 appctx->ctx.cli.msg = "set server <b>/<s> addr requires an address and optionally a port.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004397 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004398 return 1;
4399 }
4400 else {
4401 addr = args[4];
4402 }
4403 if (strcmp(args[5], "port") == 0) {
4404 port = args[6];
4405 }
4406 warning = update_server_addr_port(sv, addr, port, "stats socket command");
4407 if (warning) {
4408 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004409 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004410 }
4411 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
4412 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004413 else if (strcmp(args[3], "fqdn") == 0) {
4414 if (!*args[4]) {
4415 appctx->ctx.cli.msg = "set server <b>/<s> fqdn requires a FQDN.\n";
4416 appctx->st0 = CLI_ST_PRINT;
4417 return 1;
4418 }
4419 warning = update_server_fqdn(sv, args[4], "stats socket command");
4420 if (warning) {
4421 appctx->ctx.cli.msg = warning;
4422 appctx->st0 = CLI_ST_PRINT;
4423 }
4424 }
William Lallemand222baf22016-11-19 02:00:33 +01004425 else {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004426 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 +01004427 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004428 }
4429 return 1;
4430}
4431
William Lallemand6b160942016-11-22 12:34:35 +01004432static int cli_parse_get_weight(char **args, struct appctx *appctx, void *private)
4433{
4434 struct stream_interface *si = appctx->owner;
4435 struct proxy *px;
4436 struct server *sv;
4437 char *line;
4438
4439
4440 /* split "backend/server" and make <line> point to server */
4441 for (line = args[2]; *line; line++)
4442 if (*line == '/') {
4443 *line++ = '\0';
4444 break;
4445 }
4446
4447 if (!*line) {
4448 appctx->ctx.cli.msg = "Require 'backend/server'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004449 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004450 return 1;
4451 }
4452
4453 if (!get_backend_server(args[2], line, &px, &sv)) {
4454 appctx->ctx.cli.msg = px ? "No such server.\n" : "No such backend.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004455 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004456 return 1;
4457 }
4458
4459 /* return server's effective weight at the moment */
4460 snprintf(trash.str, trash.size, "%d (initial %d)\n", sv->uweight, sv->iweight);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004461 if (bi_putstr(si_ic(si), trash.str) == -1) {
William Lallemand6b160942016-11-22 12:34:35 +01004462 si_applet_cant_put(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004463 return 0;
4464 }
William Lallemand6b160942016-11-22 12:34:35 +01004465 return 1;
4466}
4467
4468static int cli_parse_set_weight(char **args, struct appctx *appctx, void *private)
4469{
4470 struct server *sv;
4471 const char *warning;
4472
4473 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4474 return 1;
4475
4476 sv = cli_find_server(appctx, args[2]);
4477 if (!sv)
4478 return 1;
4479
4480 warning = server_parse_weight_change_request(sv, args[3]);
4481 if (warning) {
4482 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004483 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004484 }
4485 return 1;
4486}
4487
Willy Tarreaub8026272016-11-23 11:26:56 +01004488/* parse a "set maxconn server" command. It always returns 1. */
4489static int cli_parse_set_maxconn_server(char **args, struct appctx *appctx, void *private)
4490{
4491 struct server *sv;
4492 const char *warning;
4493
4494 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4495 return 1;
4496
4497 sv = cli_find_server(appctx, args[3]);
4498 if (!sv)
4499 return 1;
4500
4501 warning = server_parse_maxconn_change_request(sv, args[4]);
4502 if (warning) {
4503 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004504 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaub8026272016-11-23 11:26:56 +01004505 }
4506 return 1;
4507}
William Lallemand6b160942016-11-22 12:34:35 +01004508
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004509/* parse a "disable agent" command. It always returns 1. */
4510static int cli_parse_disable_agent(char **args, struct appctx *appctx, void *private)
4511{
4512 struct server *sv;
4513
4514 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4515 return 1;
4516
4517 sv = cli_find_server(appctx, args[2]);
4518 if (!sv)
4519 return 1;
4520
4521 sv->agent.state &= ~CHK_ST_ENABLED;
4522 return 1;
4523}
4524
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004525/* parse a "disable health" command. It always returns 1. */
4526static int cli_parse_disable_health(char **args, struct appctx *appctx, void *private)
4527{
4528 struct server *sv;
4529
4530 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4531 return 1;
4532
4533 sv = cli_find_server(appctx, args[2]);
4534 if (!sv)
4535 return 1;
4536
4537 sv->check.state &= ~CHK_ST_ENABLED;
4538 return 1;
4539}
4540
Willy Tarreauffb4d582016-11-24 12:47:00 +01004541/* parse a "disable server" command. It always returns 1. */
4542static int cli_parse_disable_server(char **args, struct appctx *appctx, void *private)
4543{
4544 struct server *sv;
4545
4546 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4547 return 1;
4548
4549 sv = cli_find_server(appctx, args[2]);
4550 if (!sv)
4551 return 1;
4552
4553 srv_adm_set_maint(sv);
4554 return 1;
4555}
4556
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004557/* parse a "enable agent" command. It always returns 1. */
4558static int cli_parse_enable_agent(char **args, struct appctx *appctx, void *private)
4559{
4560 struct server *sv;
4561
4562 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4563 return 1;
4564
4565 sv = cli_find_server(appctx, args[2]);
4566 if (!sv)
4567 return 1;
4568
4569 if (!(sv->agent.state & CHK_ST_CONFIGURED)) {
4570 appctx->ctx.cli.msg = "Agent was not configured on this server, cannot enable.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004571 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004572 return 1;
4573 }
4574
4575 sv->agent.state |= CHK_ST_ENABLED;
4576 return 1;
4577}
4578
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004579/* parse a "enable health" command. It always returns 1. */
4580static int cli_parse_enable_health(char **args, struct appctx *appctx, void *private)
4581{
4582 struct server *sv;
4583
4584 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4585 return 1;
4586
4587 sv = cli_find_server(appctx, args[2]);
4588 if (!sv)
4589 return 1;
4590
4591 sv->check.state |= CHK_ST_ENABLED;
4592 return 1;
4593}
4594
Willy Tarreauffb4d582016-11-24 12:47:00 +01004595/* parse a "enable server" command. It always returns 1. */
4596static int cli_parse_enable_server(char **args, struct appctx *appctx, void *private)
4597{
4598 struct server *sv;
4599
4600 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4601 return 1;
4602
4603 sv = cli_find_server(appctx, args[2]);
4604 if (!sv)
4605 return 1;
4606
4607 srv_adm_set_ready(sv);
4608 return 1;
4609}
4610
William Lallemand222baf22016-11-19 02:00:33 +01004611/* register cli keywords */
4612static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004613 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004614 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004615 { { "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 +01004616 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004617 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004618 { { "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 +01004619 { { "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 +01004620 { { "set", "server", NULL }, "set server : change a server's state, weight or address", cli_parse_set_server },
William Lallemand6b160942016-11-22 12:34:35 +01004621 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4622 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4623
William Lallemand222baf22016-11-19 02:00:33 +01004624 {{},}
4625}};
4626
4627__attribute__((constructor))
4628static void __server_init(void)
4629{
4630 cli_register_kw(&cli_kws);
4631}
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004632
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004633/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004634 * Local variables:
4635 * c-indent-level: 8
4636 * c-basic-offset: 8
4637 * End:
4638 */