blob: 52c71a6788ef60f54a2e0267b5a57f7f72e13f7a [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>
Willy Tarreau0108d902018-11-25 19:14:37 +010022#include <common/initcall.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010023#include <common/namespace.h>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020024#include <common/time.h>
25
William Lallemand222baf22016-11-19 02:00:33 +010026#include <types/applet.h>
27#include <types/cli.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020028#include <types/global.h>
Willy Tarreau21b069d2016-11-23 17:15:08 +010029#include <types/cli.h>
Baptiste Assmanna68ca962015-04-14 01:15:08 +020030#include <types/dns.h>
William Lallemand222baf22016-11-19 02:00:33 +010031#include <types/stats.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020032
William Lallemand222baf22016-11-19 02:00:33 +010033#include <proto/applet.h>
34#include <proto/cli.h>
Simon Hormanb1900d52015-01-30 11:22:54 +090035#include <proto/checks.h>
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +020036#include <proto/connection.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020037#include <proto/port_range.h>
38#include <proto/protocol.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020039#include <proto/queue.h>
Frédéric Lécaille9a146de2017-03-20 14:54:41 +010040#include <proto/sample.h>
Willy Tarreauec6c5df2008-07-15 00:22:45 +020041#include <proto/server.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020042#include <proto/stream.h>
William Lallemand222baf22016-11-19 02:00:33 +010043#include <proto/stream_interface.h>
44#include <proto/stats.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020045#include <proto/task.h>
Baptiste Assmanna68ca962015-04-14 01:15:08 +020046#include <proto/dns.h>
David Carlier6f182082017-04-03 21:58:04 +010047#include <netinet/tcp.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020048
Willy Tarreau3ff577e2018-08-02 11:48:52 +020049static void srv_update_status(struct server *s);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020050static void srv_update_state(struct server *srv, int version, char **params);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010051static int srv_apply_lastaddr(struct server *srv, int *err_code);
Olivier Houchardd16bfe62017-10-31 15:21:19 +010052static int srv_set_fqdn(struct server *srv, const char *fqdn, int dns_locked);
Willy Tarreaubaaee002006-06-26 02:48:02 +020053
Willy Tarreau21faa912012-10-10 08:27:36 +020054/* List head of all known server keywords */
55static struct srv_kw_list srv_keywords = {
56 .list = LIST_HEAD_INIT(srv_keywords.list)
57};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020058
Olivier Houchard9ea5d362019-02-14 18:29:09 +010059__decl_hathreads(HA_SPINLOCK_T idle_conn_srv_lock);
60struct eb_root idle_conn_srv = EB_ROOT;
61struct task *idle_conn_task = NULL;
62struct task *idle_conn_cleanup[MAX_THREADS] = { NULL };
63struct list toremove_connections[MAX_THREADS];
64
Simon Hormana3608442013-11-01 16:46:15 +090065int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020066{
Emeric Brun52a91d32017-08-31 14:41:55 +020067 if ((s->cur_state != SRV_ST_STOPPED) && s->last_change < now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020068 return s->down_time;
69
70 return now.tv_sec - s->last_change + s->down_time;
71}
Willy Tarreaubaaee002006-06-26 02:48:02 +020072
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050073int srv_lastsession(const struct server *s)
74{
75 if (s->counters.last_sess)
76 return now.tv_sec - s->counters.last_sess;
77
78 return -1;
79}
80
Simon Horman4a741432013-02-23 15:35:38 +090081int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020082{
Simon Horman4a741432013-02-23 15:35:38 +090083 const struct server *s = check->server;
84
Willy Tarreauff5ae352013-12-11 20:36:34 +010085 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090086 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010087
Emeric Brun52a91d32017-08-31 14:41:55 +020088 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +090089 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010090
Simon Horman4a741432013-02-23 15:35:38 +090091 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010092}
93
Olivier Houcharde9bad0a2018-01-17 17:39:34 +010094/*
95 * Check that we did not get a hash collision.
96 * Unlikely, but it can happen.
97 */
98static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +010099{
100 struct proxy *p = s->proxy;
101 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100102
103 for (tmpserv = p->srv; tmpserv != NULL;
104 tmpserv = tmpserv->next) {
105 if (tmpserv == s)
106 continue;
107 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
108 continue;
109 if (tmpserv->cookie &&
110 strcmp(tmpserv->cookie, s->cookie) == 0) {
111 ha_warning("We generated two equal cookies for two different servers.\n"
112 "Please change the secret key for '%s'.\n",
113 s->proxy->id);
114 }
115 }
116
117}
118
Willy Tarreau46b7f532018-08-21 11:54:26 +0200119/*
120 * Must be called with the server lock held.
121 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100122void srv_set_dyncookie(struct server *s)
123{
124 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100125 char *tmpbuf;
126 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100127 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100128 size_t buffer_len;
129 int addr_len;
130 int port;
131
132 if ((s->flags & SRV_F_COOKIESET) ||
133 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
134 s->proxy->dyncookie_key == NULL)
135 return;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100136 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100137
138 if (s->addr.ss_family != AF_INET &&
139 s->addr.ss_family != AF_INET6)
140 return;
141 /*
142 * Buffer to calculate the cookie value.
143 * The buffer contains the secret key + the server IP address
144 * + the TCP port.
145 */
146 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
147 /*
148 * The TCP port should use only 2 bytes, but is stored in
149 * an unsigned int in struct server, so let's use 4, to be
150 * on the safe side.
151 */
152 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200153 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100154 memcpy(tmpbuf, p->dyncookie_key, key_len);
155 memcpy(&(tmpbuf[key_len]),
156 s->addr.ss_family == AF_INET ?
157 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
158 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
159 addr_len);
160 /*
161 * Make sure it's the same across all the load balancers,
162 * no matter their endianness.
163 */
164 port = htonl(s->svc_port);
165 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
166 hash_value = XXH64(tmpbuf, buffer_len, 0);
167 memprintf(&s->cookie, "%016llx", hash_value);
168 if (!s->cookie)
169 return;
170 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100171
172 /* Don't bother checking if the dyncookie is duplicated if
173 * the server is marked as "disabled", maybe it doesn't have
174 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100175 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100176 if (!(s->next_admin & SRV_ADMF_FMAINT))
177 srv_check_for_dup_dyncookie(s);
Olivier Houchard4e694042017-03-14 20:01:29 +0100178}
179
Willy Tarreau21faa912012-10-10 08:27:36 +0200180/*
181 * Registers the server keyword list <kwl> as a list of valid keywords for next
182 * parsing sessions.
183 */
184void srv_register_keywords(struct srv_kw_list *kwl)
185{
186 LIST_ADDQ(&srv_keywords.list, &kwl->list);
187}
188
189/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
190 * keyword is found with a NULL ->parse() function, then an attempt is made to
191 * find one with a valid ->parse() function. This way it is possible to declare
192 * platform-dependant, known keywords as NULL, then only declare them as valid
193 * if some options are met. Note that if the requested keyword contains an
194 * opening parenthesis, everything from this point is ignored.
195 */
196struct srv_kw *srv_find_kw(const char *kw)
197{
198 int index;
199 const char *kwend;
200 struct srv_kw_list *kwl;
201 struct srv_kw *ret = NULL;
202
203 kwend = strchr(kw, '(');
204 if (!kwend)
205 kwend = kw + strlen(kw);
206
207 list_for_each_entry(kwl, &srv_keywords.list, list) {
208 for (index = 0; kwl->kw[index].kw != NULL; index++) {
209 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
210 kwl->kw[index].kw[kwend-kw] == 0) {
211 if (kwl->kw[index].parse)
212 return &kwl->kw[index]; /* found it !*/
213 else
214 ret = &kwl->kw[index]; /* may be OK */
215 }
216 }
217 }
218 return ret;
219}
220
221/* Dumps all registered "server" keywords to the <out> string pointer. The
222 * unsupported keywords are only dumped if their supported form was not
223 * found.
224 */
225void srv_dump_kws(char **out)
226{
227 struct srv_kw_list *kwl;
228 int index;
229
230 *out = NULL;
231 list_for_each_entry(kwl, &srv_keywords.list, list) {
232 for (index = 0; kwl->kw[index].kw != NULL; index++) {
233 if (kwl->kw[index].parse ||
234 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
235 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
236 kwl->scope,
237 kwl->kw[index].kw,
238 kwl->kw[index].skip ? " <arg>" : "",
239 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
240 kwl->kw[index].parse ? "" : " (not supported)");
241 }
242 }
243 }
244}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100245
Frédéric Lécaille6e5e0d82017-03-20 16:30:18 +0100246/* Parse the "addr" server keyword */
247static int srv_parse_addr(char **args, int *cur_arg,
248 struct proxy *curproxy, struct server *newsrv, char **err)
249{
250 char *errmsg, *arg;
251 struct sockaddr_storage *sk;
252 int port1, port2;
253 struct protocol *proto;
254
255 errmsg = NULL;
256 arg = args[*cur_arg + 1];
257
258 if (!*arg) {
259 memprintf(err, "'%s' expects <ipv4|ipv6> as argument.\n", args[*cur_arg]);
260 goto err;
261 }
262
263 sk = str2sa_range(arg, NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
264 if (!sk) {
265 memprintf(err, "'%s' : %s", args[*cur_arg], errmsg);
266 goto err;
267 }
268
269 proto = protocol_by_family(sk->ss_family);
270 if (!proto || !proto->connect) {
271 memprintf(err, "'%s %s' : connect() not supported for this address family.\n",
272 args[*cur_arg], arg);
273 goto err;
274 }
275
276 if (port1 != port2) {
277 memprintf(err, "'%s' : port ranges and offsets are not allowed in '%s'\n",
278 args[*cur_arg], arg);
279 goto err;
280 }
281
282 newsrv->check.addr = newsrv->agent.addr = *sk;
283 newsrv->flags |= SRV_F_CHECKADDR;
284 newsrv->flags |= SRV_F_AGENTADDR;
285
286 return 0;
287
288 err:
289 free(errmsg);
290 return ERR_ALERT | ERR_FATAL;
291}
292
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +0100293/* Parse the "agent-check" server keyword */
294static int srv_parse_agent_check(char **args, int *cur_arg,
295 struct proxy *curproxy, struct server *newsrv, char **err)
296{
297 newsrv->do_agent = 1;
298 return 0;
299}
300
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100301/* Parse the "backup" server keyword */
302static int srv_parse_backup(char **args, int *cur_arg,
303 struct proxy *curproxy, struct server *newsrv, char **err)
304{
305 newsrv->flags |= SRV_F_BACKUP;
306 return 0;
307}
308
Frédéric Lécaille65aa3562017-03-14 11:20:13 +0100309/* Parse the "check" server keyword */
310static int srv_parse_check(char **args, int *cur_arg,
311 struct proxy *curproxy, struct server *newsrv, char **err)
312{
313 newsrv->do_check = 1;
314 return 0;
315}
316
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100317/* Parse the "check-send-proxy" server keyword */
318static int srv_parse_check_send_proxy(char **args, int *cur_arg,
319 struct proxy *curproxy, struct server *newsrv, char **err)
320{
321 newsrv->check.send_proxy = 1;
322 return 0;
323}
324
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100325/* Parse the "cookie" server keyword */
326static int srv_parse_cookie(char **args, int *cur_arg,
327 struct proxy *curproxy, struct server *newsrv, char **err)
328{
329 char *arg;
330
331 arg = args[*cur_arg + 1];
332 if (!*arg) {
333 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
334 return ERR_ALERT | ERR_FATAL;
335 }
336
337 free(newsrv->cookie);
338 newsrv->cookie = strdup(arg);
339 newsrv->cklen = strlen(arg);
340 newsrv->flags |= SRV_F_COOKIESET;
341 return 0;
342}
343
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100344/* Parse the "disabled" server keyword */
345static int srv_parse_disabled(char **args, int *cur_arg,
346 struct proxy *curproxy, struct server *newsrv, char **err)
347{
Emeric Brun52a91d32017-08-31 14:41:55 +0200348 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
349 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100350 newsrv->check.state |= CHK_ST_PAUSED;
351 newsrv->check.health = 0;
352 return 0;
353}
354
355/* Parse the "enabled" server keyword */
356static int srv_parse_enabled(char **args, int *cur_arg,
357 struct proxy *curproxy, struct server *newsrv, char **err)
358{
Emeric Brun52a91d32017-08-31 14:41:55 +0200359 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
360 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100361 newsrv->check.state &= ~CHK_ST_PAUSED;
362 newsrv->check.health = newsrv->check.rise;
363 return 0;
364}
365
Willy Tarreau9c538e02019-01-23 10:21:49 +0100366static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
367{
368 char *arg;
369
370 arg = args[*cur_arg + 1];
371 if (!*arg) {
372 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
373 return ERR_ALERT | ERR_FATAL;
374 }
375 newsrv->max_reuse = atoi(arg);
376
377 return 0;
378}
379
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100380static int srv_parse_pool_purge_delay(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100381{
382 const char *res;
383 char *arg;
384 unsigned int time;
385
386 arg = args[*cur_arg + 1];
387 if (!*arg) {
388 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
389 return ERR_ALERT | ERR_FATAL;
390 }
391 res = parse_time_err(arg, &time, TIME_UNIT_MS);
392 if (res) {
393 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
394 *res, args[*cur_arg]);
395 return ERR_ALERT | ERR_FATAL;
396 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100397 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100398
399 return 0;
400}
401
Olivier Houchard006e3102018-12-10 18:30:32 +0100402static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
403{
404 char *arg;
405
406 arg = args[*cur_arg + 1];
407 if (!*arg) {
408 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
409 return ERR_ALERT | ERR_FATAL;
410 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100411
Olivier Houchard006e3102018-12-10 18:30:32 +0100412 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100413 if ((int)newsrv->max_idle_conns < -1) {
414 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
415 return ERR_ALERT | ERR_FATAL;
416 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100417
418 return 0;
419}
420
Willy Tarreaudff55432012-10-10 17:51:05 +0200421/* parse the "id" server keyword */
422static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
423{
424 struct eb32_node *node;
425
426 if (!*args[*cur_arg + 1]) {
427 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
428 return ERR_ALERT | ERR_FATAL;
429 }
430
431 newsrv->puid = atol(args[*cur_arg + 1]);
432 newsrv->conf.id.key = newsrv->puid;
433
434 if (newsrv->puid <= 0) {
435 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
436 return ERR_ALERT | ERR_FATAL;
437 }
438
439 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
440 if (node) {
441 struct server *target = container_of(node, struct server, conf.id);
442 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
443 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
444 target->id);
445 return ERR_ALERT | ERR_FATAL;
446 }
447
448 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200449 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200450 return 0;
451}
452
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100453/* Parse the "namespace" server keyword */
454static int srv_parse_namespace(char **args, int *cur_arg,
455 struct proxy *curproxy, struct server *newsrv, char **err)
456{
Willy Tarreaue5733232019-05-22 19:24:06 +0200457#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100458 char *arg;
459
460 arg = args[*cur_arg + 1];
461 if (!*arg) {
462 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
463 return ERR_ALERT | ERR_FATAL;
464 }
465
466 if (!strcmp(arg, "*")) {
467 /* Use the namespace associated with the connection (if present). */
468 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
469 return 0;
470 }
471
472 /*
473 * As this parser may be called several times for the same 'default-server'
474 * object, or for a new 'server' instance deriving from a 'default-server'
475 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
476 */
477 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
478
479 newsrv->netns = netns_store_lookup(arg, strlen(arg));
480 if (!newsrv->netns)
481 newsrv->netns = netns_store_insert(arg);
482
483 if (!newsrv->netns) {
484 memprintf(err, "Cannot open namespace '%s'", arg);
485 return ERR_ALERT | ERR_FATAL;
486 }
487
488 return 0;
489#else
490 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
491 return ERR_ALERT | ERR_FATAL;
492#endif
493}
494
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +0100495/* Parse the "no-agent-check" server keyword */
496static int srv_parse_no_agent_check(char **args, int *cur_arg,
497 struct proxy *curproxy, struct server *newsrv, char **err)
498{
499 free_check(&newsrv->agent);
500 newsrv->agent.inter = 0;
501 newsrv->agent.port = 0;
502 newsrv->agent.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED & ~CHK_ST_AGENT;
503 newsrv->do_agent = 0;
504 return 0;
505}
506
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100507/* Parse the "no-backup" server keyword */
508static int srv_parse_no_backup(char **args, int *cur_arg,
509 struct proxy *curproxy, struct server *newsrv, char **err)
510{
511 newsrv->flags &= ~SRV_F_BACKUP;
512 return 0;
513}
514
Frédéric Lécaille65aa3562017-03-14 11:20:13 +0100515/* Parse the "no-check" server keyword */
516static int srv_parse_no_check(char **args, int *cur_arg,
517 struct proxy *curproxy, struct server *newsrv, char **err)
518{
519 free_check(&newsrv->check);
520 newsrv->check.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED;
521 newsrv->do_check = 0;
522 return 0;
523}
524
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100525/* Parse the "no-check-send-proxy" server keyword */
526static int srv_parse_no_check_send_proxy(char **args, int *cur_arg,
527 struct proxy *curproxy, struct server *newsrv, char **err)
528{
529 newsrv->check.send_proxy = 0;
530 return 0;
531}
532
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100533/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200534static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100535{
536 srv->pp_opts &= ~flags;
537 return 0;
538}
539
540/* Parse the "no-send-proxy" server keyword */
541static int srv_parse_no_send_proxy(char **args, int *cur_arg,
542 struct proxy *curproxy, struct server *newsrv, char **err)
543{
544 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
545}
546
547/* Parse the "no-send-proxy-v2" server keyword */
548static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
549 struct proxy *curproxy, struct server *newsrv, char **err)
550{
551 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
552}
553
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100554/* Parse the "non-stick" server keyword */
555static int srv_parse_non_stick(char **args, int *cur_arg,
556 struct proxy *curproxy, struct server *newsrv, char **err)
557{
558 newsrv->flags |= SRV_F_NON_STICK;
559 return 0;
560}
561
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100562/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200563static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100564{
565 srv->pp_opts |= flags;
566 return 0;
567}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200568/* parse the "proto" server keyword */
569static int srv_parse_proto(char **args, int *cur_arg,
570 struct proxy *px, struct server *newsrv, char **err)
571{
572 struct ist proto;
573
574 if (!*args[*cur_arg + 1]) {
575 memprintf(err, "'%s' : missing value", args[*cur_arg]);
576 return ERR_ALERT | ERR_FATAL;
577 }
578 proto = ist2(args[*cur_arg + 1], strlen(args[*cur_arg + 1]));
579 newsrv->mux_proto = get_mux_proto(proto);
580 if (!newsrv->mux_proto) {
581 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
582 return ERR_ALERT | ERR_FATAL;
583 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200584 return 0;
585}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100586
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100587/* parse the "proxy-v2-options" */
588static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
589 struct proxy *px, struct server *newsrv, char **err)
590{
591 char *p, *n;
592 for (p = args[*cur_arg+1]; p; p = n) {
593 n = strchr(p, ',');
594 if (n)
595 *n++ = '\0';
596 if (!strcmp(p, "ssl")) {
597 newsrv->pp_opts |= SRV_PP_V2_SSL;
598 } else if (!strcmp(p, "cert-cn")) {
599 newsrv->pp_opts |= SRV_PP_V2_SSL;
600 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100601 } else if (!strcmp(p, "cert-key")) {
602 newsrv->pp_opts |= SRV_PP_V2_SSL;
603 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
604 } else if (!strcmp(p, "cert-sig")) {
605 newsrv->pp_opts |= SRV_PP_V2_SSL;
606 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
607 } else if (!strcmp(p, "ssl-cipher")) {
608 newsrv->pp_opts |= SRV_PP_V2_SSL;
609 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100610 } else if (!strcmp(p, "authority")) {
611 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100612 } else if (!strcmp(p, "crc32c")) {
613 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100614 } else
615 goto fail;
616 }
617 return 0;
618 fail:
619 if (err)
620 memprintf(err, "'%s' : proxy v2 option not implemented", p);
621 return ERR_ALERT | ERR_FATAL;
622}
623
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100624/* Parse the "observe" server keyword */
625static int srv_parse_observe(char **args, int *cur_arg,
626 struct proxy *curproxy, struct server *newsrv, char **err)
627{
628 char *arg;
629
630 arg = args[*cur_arg + 1];
631 if (!*arg) {
632 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
633 return ERR_ALERT | ERR_FATAL;
634 }
635
636 if (!strcmp(arg, "none")) {
637 newsrv->observe = HANA_OBS_NONE;
638 }
639 else if (!strcmp(arg, "layer4")) {
640 newsrv->observe = HANA_OBS_LAYER4;
641 }
642 else if (!strcmp(arg, "layer7")) {
643 if (curproxy->mode != PR_MODE_HTTP) {
644 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
645 return ERR_ALERT;
646 }
647 newsrv->observe = HANA_OBS_LAYER7;
648 }
649 else {
650 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
651 "but got '%s'\n", args[*cur_arg], arg);
652 return ERR_ALERT | ERR_FATAL;
653 }
654
655 return 0;
656}
657
Frédéric Lécaille16186232017-03-14 16:42:49 +0100658/* Parse the "redir" server keyword */
659static int srv_parse_redir(char **args, int *cur_arg,
660 struct proxy *curproxy, struct server *newsrv, char **err)
661{
662 char *arg;
663
664 arg = args[*cur_arg + 1];
665 if (!*arg) {
666 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
667 return ERR_ALERT | ERR_FATAL;
668 }
669
670 free(newsrv->rdr_pfx);
671 newsrv->rdr_pfx = strdup(arg);
672 newsrv->rdr_len = strlen(arg);
673
674 return 0;
675}
676
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100677/* Parse the "send-proxy" server keyword */
678static int srv_parse_send_proxy(char **args, int *cur_arg,
679 struct proxy *curproxy, struct server *newsrv, char **err)
680{
681 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
682}
683
684/* Parse the "send-proxy-v2" server keyword */
685static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
686 struct proxy *curproxy, struct server *newsrv, char **err)
687{
688 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
689}
690
Frédéric Lécailledba97072017-03-17 15:33:50 +0100691
692/* Parse the "source" server keyword */
693static int srv_parse_source(char **args, int *cur_arg,
694 struct proxy *curproxy, struct server *newsrv, char **err)
695{
696 char *errmsg;
697 int port_low, port_high;
698 struct sockaddr_storage *sk;
699 struct protocol *proto;
700
701 errmsg = NULL;
702
703 if (!*args[*cur_arg + 1]) {
704 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
705 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
706 goto err;
707 }
708
709 /* 'sk' is statically allocated (no need to be freed). */
710 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, &errmsg, NULL, NULL, 1);
711 if (!sk) {
712 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
713 goto err;
714 }
715
716 proto = protocol_by_family(sk->ss_family);
717 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100718 ha_alert("'%s %s' : connect() not supported for this address family.\n",
719 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100720 goto err;
721 }
722
723 newsrv->conn_src.opts |= CO_SRC_BIND;
724 newsrv->conn_src.source_addr = *sk;
725
726 if (port_low != port_high) {
727 int i;
728
729 if (!port_low || !port_high) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100730 ha_alert("'%s' does not support port offsets (found '%s').\n",
731 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100732 goto err;
733 }
734
735 if (port_low <= 0 || port_low > 65535 ||
736 port_high <= 0 || port_high > 65535 ||
737 port_low > port_high) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100738 ha_alert("'%s': invalid source port range %d-%d.\n", args[*cur_arg], port_low, port_high);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100739 goto err;
740 }
741 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
742 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
743 newsrv->conn_src.sport_range->ports[i] = port_low + i;
744 }
745
746 *cur_arg += 2;
747 while (*(args[*cur_arg])) {
748 if (!strcmp(args[*cur_arg], "usesrc")) { /* address to use outside */
749#if defined(CONFIG_HAP_TRANSPARENT)
750 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100751 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
752 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100753 goto err;
754 }
755 if (!strcmp(args[*cur_arg + 1], "client")) {
756 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
757 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
758 }
759 else if (!strcmp(args[*cur_arg + 1], "clientip")) {
760 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
761 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
762 }
763 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
764 char *name, *end;
765
766 name = args[*cur_arg + 1] + 7;
767 while (isspace(*name))
768 name++;
769
770 end = name;
771 while (*end && !isspace(*end) && *end != ',' && *end != ')')
772 end++;
773
774 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
775 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
776 free(newsrv->conn_src.bind_hdr_name);
777 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
778 newsrv->conn_src.bind_hdr_len = end - name;
779 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
780 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
781 newsrv->conn_src.bind_hdr_occ = -1;
782
783 /* now look for an occurrence number */
784 while (isspace(*end))
785 end++;
786 if (*end == ',') {
787 end++;
788 name = end;
789 if (*end == '-')
790 end++;
791 while (isdigit((int)*end))
792 end++;
793 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
794 }
795
796 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100797 ha_alert("usesrc hdr_ip(name,num) does not support negative"
798 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100799 goto err;
800 }
801 }
802 else {
803 struct sockaddr_storage *sk;
804 int port1, port2;
805
806 /* 'sk' is statically allocated (no need to be freed). */
807 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
808 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100809 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100810 goto err;
811 }
812
813 proto = protocol_by_family(sk->ss_family);
814 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100815 ha_alert("'%s %s' : connect() not supported for this address family.\n",
816 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100817 goto err;
818 }
819
820 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100821 ha_alert("'%s' : port ranges and offsets are not allowed in '%s'\n",
822 args[*cur_arg], args[*cur_arg + 1]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100823 goto err;
824 }
825 newsrv->conn_src.tproxy_addr = *sk;
826 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
827 }
828 global.last_checks |= LSTCHK_NETADM;
829 *cur_arg += 2;
830 continue;
831#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100832 ha_alert("'usesrc' not allowed here because support for TPROXY was not compiled in.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100833 goto err;
834#endif /* defined(CONFIG_HAP_TRANSPARENT) */
835 } /* "usesrc" */
836
837 if (!strcmp(args[*cur_arg], "interface")) { /* specifically bind to this interface */
838#ifdef SO_BINDTODEVICE
839 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100840 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100841 goto err;
842 }
843 free(newsrv->conn_src.iface_name);
844 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
845 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
846 global.last_checks |= LSTCHK_NETADM;
847#else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100848 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100849 goto err;
850#endif
851 *cur_arg += 2;
852 continue;
853 }
854 /* this keyword in not an option of "source" */
855 break;
856 } /* while */
857
858 return 0;
859
860 err:
861 free(errmsg);
862 return ERR_ALERT | ERR_FATAL;
863}
864
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100865/* Parse the "stick" server keyword */
866static int srv_parse_stick(char **args, int *cur_arg,
867 struct proxy *curproxy, struct server *newsrv, char **err)
868{
869 newsrv->flags &= ~SRV_F_NON_STICK;
870 return 0;
871}
872
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100873/* Parse the "track" server keyword */
874static int srv_parse_track(char **args, int *cur_arg,
875 struct proxy *curproxy, struct server *newsrv, char **err)
876{
877 char *arg;
878
879 arg = args[*cur_arg + 1];
880 if (!*arg) {
881 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
882 return ERR_ALERT | ERR_FATAL;
883 }
884
885 free(newsrv->trackit);
886 newsrv->trackit = strdup(arg);
887
888 return 0;
889}
890
Frédéric Lécailledba97072017-03-17 15:33:50 +0100891
Willy Tarreau034c88c2017-01-23 23:36:45 +0100892/* parse the "tfo" server keyword */
893static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
894{
895 newsrv->flags |= SRV_F_FASTOPEN;
896 return 0;
897}
898
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200899/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200900 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200901 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200902 *
903 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200904 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200905void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200906{
Willy Tarreau87b09662015-04-03 00:22:06 +0200907 struct stream *stream, *stream_bck;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200908
Willy Tarreau87b09662015-04-03 00:22:06 +0200909 list_for_each_entry_safe(stream, stream_bck, &srv->actconns, by_srv)
910 if (stream->srv_conn == srv)
911 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200912}
913
914/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200915 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200916 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200917 *
918 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200919 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200920void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200921{
922 struct server *srv;
923
924 for (srv = px->srv; srv != NULL; srv = srv->next)
925 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200926 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200927}
928
Willy Tarreaubda92272014-05-20 21:55:30 +0200929/* Appends some information to a message string related to a server going UP or
930 * DOWN. If both <forced> and <reason> are null and the server tracks another
931 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +0200932 * If <check> is non-null, an entire string describing the check result will be
933 * appended after a comma and a space (eg: to report some information from the
934 * check that changed the state). In the other case, the string will be built
935 * using the check results stored into the struct server if present.
936 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +0200937 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200938 *
939 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200940 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200941void srv_append_status(struct buffer *msg, struct server *s,
942 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200943{
Emeric Brun5a133512017-10-19 14:42:30 +0200944 short status = s->op_st_chg.status;
945 short code = s->op_st_chg.code;
946 long duration = s->op_st_chg.duration;
947 char *desc = s->op_st_chg.reason;
948
949 if (check) {
950 status = check->status;
951 code = check->code;
952 duration = check->duration;
953 desc = check->desc;
954 }
955
956 if (status != -1) {
957 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
958
959 if (status >= HCHK_STATUS_L57DATA)
960 chunk_appendf(msg, ", code: %d", code);
961
962 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200963 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +0200964
965 chunk_appendf(msg, ", info: \"");
966
967 chunk_initlen(&src, desc, 0, strlen(desc));
968 chunk_asciiencode(msg, &src, '"');
969
970 chunk_appendf(msg, "\"");
971 }
972
973 if (duration >= 0)
974 chunk_appendf(msg, ", check duration: %ldms", duration);
975 }
976 else if (desc && *desc) {
977 chunk_appendf(msg, ", %s", desc);
978 }
979 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +0200980 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +0200981 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200982
983 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200984 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200985 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
986 " %d sessions active, %d requeued, %d remaining in queue",
987 s->proxy->srv_act, s->proxy->srv_bck,
988 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
989 s->cur_sess, xferred, s->nbpend);
990 else
991 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
992 " %d sessions requeued, %d total in queue",
993 s->proxy->srv_act, s->proxy->srv_bck,
994 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
995 xferred, s->nbpend);
996 }
997}
998
Emeric Brun5a133512017-10-19 14:42:30 +0200999/* Marks server <s> down, regardless of its checks' statuses. The server is
1000 * registered in a list to postpone the counting of the remaining servers on
1001 * the proxy and transfers queued streams whenever possible to other servers at
1002 * a sync point. Maintenance servers are ignored. It stores the <reason> if
1003 * non-null as the reason for going down or the available data from the check
1004 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001005 *
1006 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001007 */
Emeric Brun5a133512017-10-19 14:42:30 +02001008void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001009{
1010 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001011
Emeric Brun64cc49c2017-10-03 14:46:45 +02001012 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001013 return;
1014
Emeric Brun52a91d32017-08-31 14:41:55 +02001015 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001016 *s->op_st_chg.reason = 0;
1017 s->op_st_chg.status = -1;
1018 if (reason) {
1019 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1020 }
1021 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001022 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001023 s->op_st_chg.code = check->code;
1024 s->op_st_chg.status = check->status;
1025 s->op_st_chg.duration = check->duration;
1026 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001027
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001028 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001029 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001030
Emeric Brun9f0b4582017-10-23 14:39:51 +02001031 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001032 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001033 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001034 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001035 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001036}
1037
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001038/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001039 * in maintenance. The server is registered in a list to postpone the counting
1040 * of the remaining servers on the proxy and tries to grab requests from the
1041 * proxy at a sync point. Maintenance servers are ignored. It stores the
1042 * <reason> if non-null as the reason for going down or the available data
1043 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001044 *
1045 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001046 */
Emeric Brun5a133512017-10-19 14:42:30 +02001047void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001048{
1049 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001050
Emeric Brun64cc49c2017-10-03 14:46:45 +02001051 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001052 return;
1053
Emeric Brun52a91d32017-08-31 14:41:55 +02001054 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001055 return;
1056
Emeric Brun52a91d32017-08-31 14:41:55 +02001057 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001058 *s->op_st_chg.reason = 0;
1059 s->op_st_chg.status = -1;
1060 if (reason) {
1061 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1062 }
1063 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001064 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001065 s->op_st_chg.code = check->code;
1066 s->op_st_chg.status = check->status;
1067 s->op_st_chg.duration = check->duration;
1068 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001069
Emeric Brun64cc49c2017-10-03 14:46:45 +02001070 if (s->slowstart <= 0)
1071 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001072
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001073 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001074 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001075
Emeric Brun9f0b4582017-10-23 14:39:51 +02001076 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001077 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001078 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001079 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001080 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001081}
1082
Willy Tarreau8eb77842014-05-21 13:54:57 +02001083/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001084 * isn't in maintenance. The server is registered in a list to postpone the
1085 * counting of the remaining servers on the proxy and tries to grab requests
1086 * from the proxy. Maintenance servers are ignored. It stores the
1087 * <reason> if non-null as the reason for going down or the available data
1088 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001089 * up. Note that it makes use of the trash to build the log strings, so <reason>
1090 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001091 *
1092 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001093 */
Emeric Brun5a133512017-10-19 14:42:30 +02001094void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001095{
1096 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001097
Emeric Brun64cc49c2017-10-03 14:46:45 +02001098 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001099 return;
1100
Emeric Brun52a91d32017-08-31 14:41:55 +02001101 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001102 return;
1103
Emeric Brun52a91d32017-08-31 14:41:55 +02001104 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001105 *s->op_st_chg.reason = 0;
1106 s->op_st_chg.status = -1;
1107 if (reason) {
1108 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1109 }
1110 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001111 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001112 s->op_st_chg.code = check->code;
1113 s->op_st_chg.status = check->status;
1114 s->op_st_chg.duration = check->duration;
1115 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001116
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001117 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001118 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001119
Emeric Brun9f0b4582017-10-23 14:39:51 +02001120 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001121 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001122 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001123 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001124 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001125}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001126
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001127/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1128 * enforce either maint mode or drain mode. It is not allowed to set more than
1129 * one flag at once. The equivalent "inherited" flag is propagated to all
1130 * tracking servers. Maintenance mode disables health checks (but not agent
1131 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001132 * is done. If <cause> is non-null, it will be displayed at the end of the log
1133 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001134 *
1135 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001136 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001137void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001138{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001139 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001140
1141 if (!mode)
1142 return;
1143
1144 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001145 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001146 return;
1147
Emeric Brun52a91d32017-08-31 14:41:55 +02001148 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001149 if (cause)
1150 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1151
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001152 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001153 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001154
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001155 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001156 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1157 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001158 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001159
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001160 /* compute the inherited flag to propagate */
1161 if (mode & SRV_ADMF_MAINT)
1162 mode = SRV_ADMF_IMAINT;
1163 else if (mode & SRV_ADMF_DRAIN)
1164 mode = SRV_ADMF_IDRAIN;
1165
Emeric Brun9f0b4582017-10-23 14:39:51 +02001166 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001167 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001168 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001169 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001170 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001171}
1172
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001173/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1174 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1175 * than one flag at once. The equivalent "inherited" flag is propagated to all
1176 * tracking servers. Leaving maintenance mode re-enables health checks. When
1177 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001178 *
1179 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001180 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001181void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001182{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001183 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001184
1185 if (!mode)
1186 return;
1187
1188 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001189 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001190 return;
1191
Emeric Brun52a91d32017-08-31 14:41:55 +02001192 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001193
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001194 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001195 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001196
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001197 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001198 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1199 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001200 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001201
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001202 if (mode & SRV_ADMF_MAINT)
1203 mode = SRV_ADMF_IMAINT;
1204 else if (mode & SRV_ADMF_DRAIN)
1205 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001206
Emeric Brun9f0b4582017-10-23 14:39:51 +02001207 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001208 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001209 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001210 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001211 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001212}
1213
Willy Tarreau757478e2016-11-03 19:22:19 +01001214/* principle: propagate maint and drain to tracking servers. This is useful
1215 * upon startup so that inherited states are correct.
1216 */
1217static void srv_propagate_admin_state(struct server *srv)
1218{
1219 struct server *srv2;
1220
1221 if (!srv->trackers)
1222 return;
1223
1224 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001225 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001226 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001227 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001228
Emeric Brun52a91d32017-08-31 14:41:55 +02001229 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001230 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001231 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001232 }
1233}
1234
1235/* Compute and propagate the admin states for all servers in proxy <px>.
1236 * Only servers *not* tracking another one are considered, because other
1237 * ones will be handled when the server they track is visited.
1238 */
1239void srv_compute_all_admin_states(struct proxy *px)
1240{
1241 struct server *srv;
1242
1243 for (srv = px->srv; srv; srv = srv->next) {
1244 if (srv->track)
1245 continue;
1246 srv_propagate_admin_state(srv);
1247 }
1248}
1249
Willy Tarreaudff55432012-10-10 17:51:05 +02001250/* Note: must not be declared <const> as its list will be overwritten.
1251 * Please take care of keeping this list alphabetically sorted, doing so helps
1252 * all code contributors.
1253 * Optional keywords are also declared with a NULL ->parse() function so that
1254 * the config parser can report an appropriate error when a known keyword was
1255 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001256 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001257 */
1258static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille6e5e0d82017-03-20 16:30:18 +01001259 { "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 +01001260 { "agent-check", srv_parse_agent_check, 0, 1 }, /* Enable an auxiliary agent check */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001261 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille65aa3562017-03-14 11:20:13 +01001262 { "check", srv_parse_check, 0, 1 }, /* enable health checks */
Frédéric Lécaille25df8902017-03-10 14:04:31 +01001263 { "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 +01001264 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001265 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1266 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001267 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Willy Tarreau9c538e02019-01-23 10:21:49 +01001268 { "max-reuse", srv_parse_max_reuse, 1, 1 }, /* Set the max number of requests on a connection, -1 means unlimited */
Frédéric Lécaille22f41a22017-03-16 17:17:36 +01001269 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001270 { "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 +01001271 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille65aa3562017-03-14 11:20:13 +01001272 { "no-check", srv_parse_no_check, 0, 1 }, /* disable health checks */
Frédéric Lécaille25df8902017-03-10 14:04:31 +01001273 { "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 +01001274 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1275 { "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 +01001276 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001277 { "observe", srv_parse_observe, 1, 1 }, /* Enables health adjusting based on observing communication with the server */
Olivier Houchard006e3102018-12-10 18:30:32 +01001278 { "pool-max-conn", srv_parse_pool_max_conn, 1, 1 }, /* Set the max number of orphan idle connections, 0 means unlimited */
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001279 { "pool-purge-delay", srv_parse_pool_purge_delay, 1, 1 }, /* Set the time before we destroy orphan idle connections, defaults to 1s */
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001280 { "proto", srv_parse_proto, 1, 1 }, /* Set the proto to use for all outgoing connections */
Emmanuel Hocdetf643b802018-02-01 15:20:32 +01001281 { "proxy-v2-options", srv_parse_proxy_v2_options, 1, 1 }, /* options for send-proxy-v2 */
Frédéric Lécaille16186232017-03-14 16:42:49 +01001282 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001283 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1284 { "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 +02001285 { "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 +01001286 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Willy Tarreau034c88c2017-01-23 23:36:45 +01001287 { "tfo", srv_parse_tfo, 0, 0 }, /* enable TCP Fast Open of server */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001288 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Willy Tarreaudff55432012-10-10 17:51:05 +02001289 { NULL, NULL, 0 },
1290}};
1291
Willy Tarreau0108d902018-11-25 19:14:37 +01001292INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001293
Willy Tarreau004e0452013-11-21 11:22:01 +01001294/* Recomputes the server's eweight based on its state, uweight, the current time,
1295 * and the proxy's algorihtm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001296 * state is automatically disabled if the time is elapsed. If <must_update> is
1297 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001298 *
1299 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001300 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001301void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001302{
1303 struct proxy *px = sv->proxy;
1304 unsigned w;
1305
1306 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1307 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001308 if (sv->next_state == SRV_ST_STARTING)
1309 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001310 }
1311
1312 /* We must take care of not pushing the server to full throttle during slow starts.
1313 * It must also start immediately, at least at the minimal step when leaving maintenance.
1314 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001315 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001316 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1317 else
1318 w = px->lbprm.wdiv;
1319
Emeric Brun52a91d32017-08-31 14:41:55 +02001320 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001321
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001322 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001323 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001324 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001325}
1326
Willy Tarreaubaaee002006-06-26 02:48:02 +02001327/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001328 * Parses weight_str and configures sv accordingly.
1329 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001330 *
1331 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001332 */
1333const char *server_parse_weight_change_request(struct server *sv,
1334 const char *weight_str)
1335{
1336 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001337 long int w;
1338 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001339
1340 px = sv->proxy;
1341
1342 /* if the weight is terminated with '%', it is set relative to
1343 * the initial weight, otherwise it is absolute.
1344 */
1345 if (!*weight_str)
1346 return "Require <weight> or <weight%>.\n";
1347
Simon Hormanb796afa2013-02-12 10:45:53 +09001348 w = strtol(weight_str, &end, 10);
1349 if (end == weight_str)
1350 return "Empty weight string empty or preceded by garbage";
1351 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001352 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001353 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001354 /* Avoid integer overflow */
1355 if (w > 25600)
1356 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001357 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001358 if (w > 256)
1359 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001360 }
1361 else if (w < 0 || w > 256)
1362 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001363 else if (end[0] != '\0')
1364 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001365
1366 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1367 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1368
1369 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001370 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001371
1372 return NULL;
1373}
1374
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001375/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001376 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1377 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001378 * Returns:
1379 * - error string on error
1380 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001381 *
1382 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001383 */
1384const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001385 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001386{
1387 unsigned char ip[INET6_ADDRSTRLEN];
1388
1389 if (inet_pton(AF_INET6, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001390 update_server_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001391 return NULL;
1392 }
1393 if (inet_pton(AF_INET, addr_str, ip)) {
Thierry Fournier09a91782016-02-24 08:25:39 +01001394 update_server_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001395 return NULL;
1396 }
1397
1398 return "Could not understand IP address format.\n";
1399}
1400
Willy Tarreau46b7f532018-08-21 11:54:26 +02001401/*
1402 * Must be called with the server lock held.
1403 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001404const char *server_parse_maxconn_change_request(struct server *sv,
1405 const char *maxconn_str)
1406{
1407 long int v;
1408 char *end;
1409
1410 if (!*maxconn_str)
1411 return "Require <maxconn>.\n";
1412
1413 v = strtol(maxconn_str, &end, 10);
1414 if (end == maxconn_str)
1415 return "maxconn string empty or preceded by garbage";
1416 else if (end[0] != '\0')
1417 return "Trailing garbage in maxconn string";
1418
1419 if (sv->maxconn == sv->minconn) { // static maxconn
1420 sv->maxconn = sv->minconn = v;
1421 } else { // dynamic maxconn
1422 sv->maxconn = v;
1423 }
1424
1425 if (may_dequeue_tasks(sv, sv->proxy))
1426 process_srv_queue(sv);
1427
1428 return NULL;
1429}
1430
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001431#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001432static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1433 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001434{
1435 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001436 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001437 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001438 NULL,
1439 };
1440
1441 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001442 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001443
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001444 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args);
1445}
1446
1447static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1448{
1449 struct sample_expr *expr;
1450
1451 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 +01001452 if (!expr) {
1453 memprintf(err, "error detected while parsing sni expression : %s", *err);
1454 return ERR_ALERT | ERR_FATAL;
1455 }
1456
1457 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1458 memprintf(err, "error detected while parsing sni expression : "
1459 " fetch method '%s' extracts information from '%s', "
1460 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001461 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001462 return ERR_ALERT | ERR_FATAL;
1463 }
1464
1465 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1466 release_sample_expr(newsrv->ssl_ctx.sni);
1467 newsrv->ssl_ctx.sni = expr;
1468
1469 return 0;
1470}
1471#endif
1472
1473static void display_parser_err(const char *file, int linenum, char **args, int cur_arg, char **err)
1474{
1475 if (err && *err) {
1476 indent_msg(err, 2);
Christopher Faulet767a84b2017-11-24 16:50:31 +01001477 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], *err);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001478 }
1479 else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001480 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while processing '%s'.\n",
1481 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001482}
1483
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001484static void srv_conn_src_sport_range_cpy(struct server *srv,
1485 struct server *src)
1486{
1487 int range_sz;
1488
1489 range_sz = src->conn_src.sport_range->size;
1490 if (range_sz > 0) {
1491 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1492 if (srv->conn_src.sport_range != NULL) {
1493 int i;
1494
1495 for (i = 0; i < range_sz; i++) {
1496 srv->conn_src.sport_range->ports[i] =
1497 src->conn_src.sport_range->ports[i];
1498 }
1499 }
1500 }
1501}
1502
1503/*
1504 * Copy <src> server connection source settings to <srv> server everything needed.
1505 */
1506static void srv_conn_src_cpy(struct server *srv, struct server *src)
1507{
1508 srv->conn_src.opts = src->conn_src.opts;
1509 srv->conn_src.source_addr = src->conn_src.source_addr;
1510
1511 /* Source port range copy. */
1512 if (src->conn_src.sport_range != NULL)
1513 srv_conn_src_sport_range_cpy(srv, src);
1514
1515#ifdef CONFIG_HAP_TRANSPARENT
1516 if (src->conn_src.bind_hdr_name != NULL) {
1517 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1518 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1519 }
1520 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1521 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1522#endif
1523 if (src->conn_src.iface_name != NULL)
1524 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1525}
1526
1527/*
1528 * Copy <src> server SSL settings to <srv> server allocating
1529 * everything needed.
1530 */
1531#if defined(USE_OPENSSL)
1532static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1533{
1534 if (src->ssl_ctx.ca_file != NULL)
1535 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1536 if (src->ssl_ctx.crl_file != NULL)
1537 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
1538 if (src->ssl_ctx.client_crt != NULL)
1539 srv->ssl_ctx.client_crt = strdup(src->ssl_ctx.client_crt);
1540
1541 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1542
1543 if (src->ssl_ctx.verify_host != NULL)
1544 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1545 if (src->ssl_ctx.ciphers != NULL)
1546 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Willy Tarreau5db847a2019-05-09 14:13:35 +02001547#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L && !defined OPENSSL_IS_BORINGSSL)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001548 if (src->ssl_ctx.ciphersuites != NULL)
1549 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
1550#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001551 if (src->sni_expr != NULL)
1552 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001553
1554#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
1555 if (src->ssl_ctx.alpn_str) {
1556 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1557 if (srv->ssl_ctx.alpn_str) {
1558 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1559 src->ssl_ctx.alpn_len);
1560 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1561 }
1562 }
1563#endif
1564#ifdef OPENSSL_NPN_NEGOTIATED
1565 if (src->ssl_ctx.npn_str) {
1566 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1567 if (srv->ssl_ctx.npn_str) {
1568 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1569 src->ssl_ctx.npn_len);
1570 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1571 }
1572 }
1573#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001574}
1575#endif
1576
1577/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001578 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001579 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001580 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001581 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001582static int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001583{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001584 char *hostname_dn;
1585 int hostname_len, hostname_dn_len;
1586
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001587 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001588 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001589
Christopher Faulet67957bd2017-09-27 11:00:59 +02001590 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001591 hostname_dn = trash.area;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001592 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
1593 hostname_dn, trash.size);
1594 if (hostname_dn_len == -1)
1595 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001596
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001597
Christopher Faulet67957bd2017-09-27 11:00:59 +02001598 free(srv->hostname);
1599 free(srv->hostname_dn);
1600 srv->hostname = strdup(hostname);
1601 srv->hostname_dn = strdup(hostname_dn);
1602 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001603 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001604 goto err;
1605
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001606 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001607
1608 err:
Christopher Faulet67957bd2017-09-27 11:00:59 +02001609 free(srv->hostname); srv->hostname = NULL;
1610 free(srv->hostname_dn); srv->hostname_dn = NULL;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001611 return -1;
1612}
1613
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001614/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001615 * Copy <src> server settings to <srv> server allocating
1616 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001617 * This function is not supposed to be called at any time, but only
1618 * during server settings parsing or during server allocations from
1619 * a server template, and just after having calloc()'ed a new server.
1620 * So, <src> may only be a default server (when parsing server settings)
1621 * or a server template (during server allocations from a server template).
1622 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1623 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001624 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001625static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001626{
1627 /* Connection source settings copy */
1628 srv_conn_src_cpy(srv, src);
1629
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001630 if (srv_tmpl) {
1631 srv->addr = src->addr;
1632 srv->svc_port = src->svc_port;
1633 }
1634
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001635 srv->pp_opts = src->pp_opts;
1636 if (src->rdr_pfx != NULL) {
1637 srv->rdr_pfx = strdup(src->rdr_pfx);
1638 srv->rdr_len = src->rdr_len;
1639 }
1640 if (src->cookie != NULL) {
1641 srv->cookie = strdup(src->cookie);
1642 srv->cklen = src->cklen;
1643 }
1644 srv->use_ssl = src->use_ssl;
1645 srv->check.addr = srv->agent.addr = src->check.addr;
1646 srv->check.use_ssl = src->check.use_ssl;
1647 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01001648 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01001649 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05001650 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001651 /* Note: 'flags' field has potentially been already initialized. */
1652 srv->flags |= src->flags;
1653 srv->do_check = src->do_check;
1654 srv->do_agent = src->do_agent;
1655 if (srv->check.port)
1656 srv->flags |= SRV_F_CHECKPORT;
1657 srv->check.inter = src->check.inter;
1658 srv->check.fastinter = src->check.fastinter;
1659 srv->check.downinter = src->check.downinter;
1660 srv->agent.use_ssl = src->agent.use_ssl;
1661 srv->agent.port = src->agent.port;
1662 if (src->agent.send_string != NULL)
1663 srv->agent.send_string = strdup(src->agent.send_string);
1664 srv->agent.send_string_len = src->agent.send_string_len;
1665 srv->agent.inter = src->agent.inter;
1666 srv->agent.fastinter = src->agent.fastinter;
1667 srv->agent.downinter = src->agent.downinter;
1668 srv->maxqueue = src->maxqueue;
1669 srv->minconn = src->minconn;
1670 srv->maxconn = src->maxconn;
1671 srv->slowstart = src->slowstart;
1672 srv->observe = src->observe;
1673 srv->onerror = src->onerror;
1674 srv->onmarkeddown = src->onmarkeddown;
1675 srv->onmarkedup = src->onmarkedup;
1676 if (src->trackit != NULL)
1677 srv->trackit = strdup(src->trackit);
1678 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1679 srv->uweight = srv->iweight = src->iweight;
1680
1681 srv->check.send_proxy = src->check.send_proxy;
1682 /* health: up, but will fall down at first failure */
1683 srv->check.rise = srv->check.health = src->check.rise;
1684 srv->check.fall = src->check.fall;
1685
1686 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001687 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1688 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1689 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001690 srv->check.state |= CHK_ST_PAUSED;
1691 srv->check.health = 0;
1692 }
1693
1694 /* health: up but will fall down at first failure */
1695 srv->agent.rise = srv->agent.health = src->agent.rise;
1696 srv->agent.fall = src->agent.fall;
1697
1698 if (src->resolvers_id != NULL)
1699 srv->resolvers_id = strdup(src->resolvers_id);
1700 srv->dns_opts.family_prio = src->dns_opts.family_prio;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02001701 srv->dns_opts.accept_duplicate_ip = src->dns_opts.accept_duplicate_ip;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001702 if (srv->dns_opts.family_prio == AF_UNSPEC)
1703 srv->dns_opts.family_prio = AF_INET6;
1704 memcpy(srv->dns_opts.pref_net,
1705 src->dns_opts.pref_net,
1706 sizeof srv->dns_opts.pref_net);
1707 srv->dns_opts.pref_net_nb = src->dns_opts.pref_net_nb;
1708
1709 srv->init_addr_methods = src->init_addr_methods;
1710 srv->init_addr = src->init_addr;
1711#if defined(USE_OPENSSL)
1712 srv_ssl_settings_cpy(srv, src);
1713#endif
1714#ifdef TCP_USER_TIMEOUT
1715 srv->tcp_ut = src->tcp_ut;
1716#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001717 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001718 srv->pool_purge_delay = src->pool_purge_delay;
Olivier Houchard006e3102018-12-10 18:30:32 +01001719 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01001720 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001721
Olivier Houchard8da5f982017-08-04 18:35:36 +02001722 if (srv_tmpl)
1723 srv->srvrq = src->srvrq;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001724}
1725
William Lallemand313bfd12018-10-26 14:47:32 +02001726struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001727{
1728 struct server *srv;
1729
1730 srv = calloc(1, sizeof *srv);
1731 if (!srv)
1732 return NULL;
1733
1734 srv->obj_type = OBJ_TYPE_SERVER;
1735 srv->proxy = proxy;
1736 LIST_INIT(&srv->actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04001737 srv->pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02001738
Emeric Brun52a91d32017-08-31 14:41:55 +02001739 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001740 srv->last_change = now.tv_sec;
1741
1742 srv->check.status = HCHK_STATUS_INI;
1743 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01001744 srv->check.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001745 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
1746
1747 srv->agent.status = HCHK_STATUS_INI;
1748 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01001749 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001750 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
1751
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001752 srv->pool_purge_delay = 1000;
Olivier Houchard006e3102018-12-10 18:30:32 +01001753 srv->max_idle_conns = -1;
Willy Tarreau9c538e02019-01-23 10:21:49 +01001754 srv->max_reuse = -1;
Olivier Houchard006e3102018-12-10 18:30:32 +01001755
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001756 return srv;
1757}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001758
1759/*
1760 * Validate <srv> server health-check settings.
1761 * Returns 0 if everything is OK, -1 if not.
1762 */
1763static int server_healthcheck_validate(const char *file, int linenum, struct server *srv)
1764{
1765 struct tcpcheck_rule *r = NULL;
1766 struct list *l;
1767
1768 /*
1769 * We need at least a service port, a check port or the first tcp-check rule must
1770 * be a 'connect' one when checking an IPv4/IPv6 server.
1771 */
1772 if ((srv_check_healthcheck_port(&srv->check) != 0) ||
1773 (!is_inet_addr(&srv->check.addr) && (is_addr(&srv->check.addr) || !is_inet_addr(&srv->addr))))
1774 return 0;
1775
1776 r = (struct tcpcheck_rule *)srv->proxy->tcpcheck_rules.n;
1777 if (!r) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001778 ha_alert("parsing [%s:%d] : server %s has neither service port nor check port. "
1779 "Check has been disabled.\n",
1780 file, linenum, srv->id);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001781 return -1;
1782 }
1783
1784 /* search the first action (connect / send / expect) in the list */
1785 l = &srv->proxy->tcpcheck_rules;
1786 list_for_each_entry(r, l, list) {
1787 if (r->action != TCPCHK_ACT_COMMENT)
1788 break;
1789 }
1790
1791 if ((r->action != TCPCHK_ACT_CONNECT) || !r->port) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001792 ha_alert("parsing [%s:%d] : server %s has neither service port nor check port "
1793 "nor tcp_check rule 'connect' with port information. Check has been disabled.\n",
1794 file, linenum, srv->id);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001795 return -1;
1796 }
1797
1798 /* scan the tcp-check ruleset to ensure a port has been configured */
1799 l = &srv->proxy->tcpcheck_rules;
1800 list_for_each_entry(r, l, list) {
1801 if ((r->action == TCPCHK_ACT_CONNECT) && (!r->port)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001802 ha_alert("parsing [%s:%d] : server %s has neither service port nor check port, "
1803 "and a tcp_check rule 'connect' with no port information. Check has been disabled.\n",
1804 file, linenum, srv->id);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001805 return -1;
1806 }
1807 }
1808
1809 return 0;
1810}
1811
1812/*
1813 * Initialize <srv> health-check structure.
1814 * Returns the error string in case of memory allocation failure, NULL if not.
1815 */
1816static const char *do_health_check_init(struct server *srv, int check_type, int state)
1817{
1818 const char *ret;
1819
1820 if (!srv->do_check)
1821 return NULL;
1822
1823 ret = init_check(&srv->check, check_type);
1824 if (ret)
1825 return ret;
1826
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001827 srv->check.state |= state;
1828 global.maxsock++;
1829
1830 return NULL;
1831}
1832
1833static int server_health_check_init(const char *file, int linenum,
1834 struct server *srv, struct proxy *curproxy)
1835{
1836 const char *ret;
1837
1838 if (!srv->do_check)
1839 return 0;
1840
1841 if (srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001842 ha_alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1843 file, linenum);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001844 return ERR_ALERT | ERR_FATAL;
1845 }
1846
1847 if (server_healthcheck_validate(file, linenum, srv) < 0)
1848 return ERR_ALERT | ERR_ABORT;
1849
1850 /* note: check type will be set during the config review phase */
1851 ret = do_health_check_init(srv, 0, CHK_ST_CONFIGURED | CHK_ST_ENABLED);
1852 if (ret) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001853 ha_alert("parsing [%s:%d] : %s.\n", file, linenum, ret);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001854 return ERR_ALERT | ERR_ABORT;
1855 }
1856
1857 return 0;
1858}
1859
1860/*
1861 * Initialize <srv> agent check structure.
1862 * Returns the error string in case of memory allocation failure, NULL if not.
1863 */
1864static const char *do_server_agent_check_init(struct server *srv, int state)
1865{
1866 const char *ret;
1867
1868 if (!srv->do_agent)
1869 return NULL;
1870
1871 ret = init_check(&srv->agent, PR_O2_LB_AGENT_CHK);
1872 if (ret)
1873 return ret;
1874
1875 if (!srv->agent.inter)
1876 srv->agent.inter = srv->check.inter;
1877
1878 srv->agent.state |= state;
1879 global.maxsock++;
1880
1881 return NULL;
1882}
1883
1884static int server_agent_check_init(const char *file, int linenum,
1885 struct server *srv, struct proxy *curproxy)
1886{
1887 const char *ret;
1888
1889 if (!srv->do_agent)
1890 return 0;
1891
1892 if (!srv->agent.port) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001893 ha_alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001894 file, linenum, srv->id);
1895 return ERR_ALERT | ERR_FATAL;
1896 }
1897
1898 ret = do_server_agent_check_init(srv, CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT);
1899 if (ret) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001900 ha_alert("parsing [%s:%d] : %s.\n", file, linenum, ret);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001901 return ERR_ALERT | ERR_ABORT;
1902 }
1903
1904 return 0;
1905}
1906
1907#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1908static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
1909 struct server *srv, struct proxy *proxy)
1910{
1911 int ret;
1912 char *err = NULL;
1913
1914 if (!srv->sni_expr)
1915 return 0;
1916
1917 ret = server_parse_sni_expr(srv, proxy, &err);
1918 if (!ret)
1919 return 0;
1920
1921 display_parser_err(file, linenum, args, cur_arg, &err);
1922 free(err);
1923
1924 return ret;
1925}
1926#endif
1927
1928/*
1929 * Server initializations finalization.
1930 * Initialize health check, agent check and SNI expression if enabled.
1931 * Must not be called for a default server instance.
1932 */
1933static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
1934 struct server *srv, struct proxy *px)
1935{
1936 int ret;
1937
1938 if ((ret = server_health_check_init(file, linenum, srv, px)) != 0 ||
1939 (ret = server_agent_check_init(file, linenum, srv, px)) != 0) {
1940 return ret;
1941 }
1942
1943#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1944 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
1945 return ret;
1946#endif
1947
1948 if (srv->flags & SRV_F_BACKUP)
1949 px->srv_bck++;
1950 else
1951 px->srv_act++;
1952 srv_lb_commit_status(srv);
1953
1954 return 0;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01001955err:
1956 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001957}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001958
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001959/*
1960 * Parse as much as possible such a range string argument: low[-high]
1961 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
1962 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
1963 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
1964 * Returns 0 if succeeded, -1 if not.
1965 */
1966static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
1967{
1968 char *nb_high_arg;
1969
1970 *nb_high = 0;
1971 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001972 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001973
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001974 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001975 *nb_high_arg++ = '\0';
1976 *nb_high = atoi(nb_high_arg);
1977 }
1978 else {
1979 *nb_high += *nb_low;
1980 *nb_low = 1;
1981 }
1982
1983 if (*nb_low < 0 || *nb_high < *nb_low)
1984 return -1;
1985
1986 return 0;
1987}
1988
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001989static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
1990{
1991 chunk_printf(&trash, "%s%d", prefix, nb);
1992 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001993 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001994}
1995
1996/*
1997 * Initialize as much as possible servers from <srv> server template.
1998 * Note that a server template is a special server with
1999 * a few different parameters than a server which has
2000 * been parsed mostly the same way as a server.
Joseph Herlant44466822018-11-15 08:57:51 -08002001 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002002 * 'srv' template included.
2003 */
2004static int server_template_init(struct server *srv, struct proxy *px)
2005{
2006 int i;
2007 struct server *newsrv;
2008
2009 for (i = srv->tmpl_info.nb_low + 1; i <= srv->tmpl_info.nb_high; i++) {
2010 int check_init_state;
2011 int agent_init_state;
2012
2013 newsrv = new_server(px);
2014 if (!newsrv)
2015 goto err;
2016
2017 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002018 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002019#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2020 if (newsrv->sni_expr) {
2021 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
2022 if (!newsrv->ssl_ctx.sni)
2023 goto err;
2024 }
2025#endif
2026 /* Set this new server ID. */
2027 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
2028
2029 /* Initial checks states. */
2030 check_init_state = CHK_ST_CONFIGURED | CHK_ST_ENABLED;
2031 agent_init_state = CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT;
2032
2033 if (do_health_check_init(newsrv, px->options2 & PR_O2_CHK_ANY, check_init_state) ||
2034 do_server_agent_check_init(newsrv, agent_init_state))
2035 goto err;
2036
2037 /* Linked backwards first. This will be restablished after parsing. */
2038 newsrv->next = px->srv;
2039 px->srv = newsrv;
2040 }
2041 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
2042
2043 return i - srv->tmpl_info.nb_low;
2044
2045 err:
2046 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
2047 if (newsrv) {
2048#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
2049 release_sample_expr(newsrv->ssl_ctx.sni);
2050#endif
2051 free_check(&newsrv->agent);
2052 free_check(&newsrv->check);
2053 }
2054 free(newsrv);
2055 return i - srv->tmpl_info.nb_low;
2056}
2057
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002058int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy, struct proxy *defproxy, int parse_addr)
Willy Tarreau272adea2014-03-31 10:39:59 +02002059{
2060 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002061 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02002062 char *errmsg = NULL;
2063 int err_code = 0;
2064 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02002065 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02002066
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002067 if (!strcmp(args[0], "server") ||
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002068 !strcmp(args[0], "peer") ||
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002069 !strcmp(args[0], "default-server") ||
2070 !strcmp(args[0], "server-template")) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002071 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01002072 int defsrv = (*args[0] == 'd');
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002073 int srv = !defsrv && (*args[0] == 'p' || !strcmp(args[0], "server"));
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002074 int srv_tmpl = !defsrv && !srv;
2075 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002076
2077 if (!defsrv && curproxy == defproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002078 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002079 err_code |= ERR_ALERT | ERR_FATAL;
2080 goto out;
2081 }
2082 else if (warnifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL))
Olivier Houchard306e6532018-07-24 16:48:59 +02002083 err_code |= ERR_WARN;
Willy Tarreau272adea2014-03-31 10:39:59 +02002084
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002085 /* There is no mandatory first arguments for default server. */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002086 if (srv && parse_addr) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002087 if (!*args[2]) {
2088 /* 'server' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002089 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002090 file, linenum, args[0]);
2091 err_code |= ERR_ALERT | ERR_FATAL;
2092 goto out;
2093 }
2094
2095 err = invalid_char(args[1]);
2096 }
2097 else if (srv_tmpl) {
2098 if (!*args[3]) {
2099 /* 'server-template' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002100 ha_alert("parsing [%s:%d] : '%s' expects <prefix> <nb | range> <addr>[:<port>] as arguments.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002101 file, linenum, args[0]);
2102 err_code |= ERR_ALERT | ERR_FATAL;
2103 goto out;
2104 }
2105
2106 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002107 }
2108
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002109 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002110 ha_alert("parsing [%s:%d] : character '%c' is not permitted in %s %s '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002111 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002112 err_code |= ERR_ALERT | ERR_FATAL;
2113 goto out;
2114 }
2115
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002116 cur_arg = 2;
2117 if (srv_tmpl) {
2118 /* Parse server-template <nb | range> arg. */
2119 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002120 ha_alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002121 file, linenum, args[0], args[cur_arg]);
2122 err_code |= ERR_ALERT | ERR_FATAL;
2123 goto out;
2124 }
2125 cur_arg++;
2126 }
2127
Willy Tarreau272adea2014-03-31 10:39:59 +02002128 if (!defsrv) {
2129 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002130 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002131 struct protocol *proto;
2132
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002133 newsrv = new_server(curproxy);
2134 if (!newsrv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002135 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Willy Tarreau272adea2014-03-31 10:39:59 +02002136 err_code |= ERR_ALERT | ERR_ABORT;
2137 goto out;
2138 }
2139
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002140 if (srv_tmpl) {
2141 newsrv->tmpl_info.nb_low = tmpl_range_low;
2142 newsrv->tmpl_info.nb_high = tmpl_range_high;
2143 }
2144
Willy Tarreau272adea2014-03-31 10:39:59 +02002145 /* the servers are linked backwards first */
2146 newsrv->next = curproxy->srv;
2147 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02002148 newsrv->conf.file = strdup(file);
2149 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002150 /* Note: for a server template, its id is its prefix.
2151 * This is a temporary id which will be used for server allocations to come
2152 * after parsing.
2153 */
2154 if (srv)
2155 newsrv->id = strdup(args[1]);
2156 else
2157 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002158
2159 /* several ways to check the port component :
2160 * - IP => port=+0, relative (IPv4 only)
2161 * - IP: => port=+0, relative
2162 * - IP:N => port=N, absolute
2163 * - IP:+N => port=+N, relative
2164 * - IP:-N => port=-N, relative
2165 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002166 if (!parse_addr)
2167 goto skip_addr;
2168
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002169 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, &errmsg, NULL, &fqdn, 0);
Willy Tarreau272adea2014-03-31 10:39:59 +02002170 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002171 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau272adea2014-03-31 10:39:59 +02002172 err_code |= ERR_ALERT | ERR_FATAL;
2173 goto out;
2174 }
2175
2176 proto = protocol_by_family(sk->ss_family);
Willy Tarreau9698f4b2017-01-06 18:42:57 +01002177 if (!fqdn && (!proto || !proto->connect)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002178 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002179 file, linenum, args[0], args[1]);
2180 err_code |= ERR_ALERT | ERR_FATAL;
2181 goto out;
2182 }
2183
2184 if (!port1 || !port2) {
2185 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002186 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002187 }
2188 else if (port1 != port2) {
2189 /* port range */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002190 ha_alert("parsing [%s:%d] : '%s %s' : port ranges are not allowed in '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002191 file, linenum, args[0], args[1], args[2]);
2192 err_code |= ERR_ALERT | ERR_FATAL;
2193 goto out;
2194 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002195
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002196 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002197 if (fqdn) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002198 if (fqdn[0] == '_') { /* SRV record */
Olivier Houchard8da5f982017-08-04 18:35:36 +02002199 /* Check if a SRV request already exists, and if not, create it */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002200 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
2201 newsrv->srvrq = new_dns_srvrq(newsrv, fqdn);
2202 if (newsrv->srvrq == NULL) {
Olivier Houchard8da5f982017-08-04 18:35:36 +02002203 err_code |= ERR_ALERT | ERR_FATAL;
2204 goto out;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002205 }
2206 }
2207 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002208 ha_alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
Christopher Faulet67957bd2017-09-27 11:00:59 +02002209 file, linenum, newsrv->id);
2210 err_code |= ERR_ALERT | ERR_FATAL;
2211 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002212 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002213 }
2214
Willy Tarreau272adea2014-03-31 10:39:59 +02002215 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002216 newsrv->svc_port = port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002217
Olivier Houchard8da5f982017-08-04 18:35:36 +02002218 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002219 ha_alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002220 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002221 err_code |= ERR_ALERT | ERR_FATAL;
2222 goto out;
2223 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002224
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002225 cur_arg++;
2226 skip_addr:
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002227 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002228 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002229 HA_SPIN_INIT(&newsrv->lock);
Willy Tarreau272adea2014-03-31 10:39:59 +02002230 } else {
2231 newsrv = &curproxy->defsrv;
2232 cur_arg = 1;
Thierry Fournierada34842016-02-17 21:25:09 +01002233 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002234 newsrv->dns_opts.accept_duplicate_ip = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002235 }
2236
2237 while (*args[cur_arg]) {
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01002238 if (!strcmp(args[cur_arg], "agent-inter")) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002239 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2240 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002241 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'agent-inter' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002242 file, linenum, *err, newsrv->id);
2243 err_code |= ERR_ALERT | ERR_FATAL;
2244 goto out;
2245 }
2246 if (val <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002247 ha_alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002248 file, linenum, val, args[cur_arg], newsrv->id);
2249 err_code |= ERR_ALERT | ERR_FATAL;
2250 goto out;
2251 }
2252 newsrv->agent.inter = val;
2253 cur_arg += 2;
2254 }
Misiekea849332017-01-09 09:39:51 +01002255 else if (!strcmp(args[cur_arg], "agent-addr")) {
2256 if(str2ip(args[cur_arg + 1], &newsrv->agent.addr) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002257 ha_alert("parsing agent-addr failed. Check if %s is correct address.\n", args[cur_arg + 1]);
Misiekea849332017-01-09 09:39:51 +01002258 goto out;
2259 }
2260
2261 cur_arg += 2;
2262 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002263 else if (!strcmp(args[cur_arg], "agent-port")) {
2264 global.maxsock++;
2265 newsrv->agent.port = atol(args[cur_arg + 1]);
2266 cur_arg += 2;
2267 }
James Brown55f9ff12015-10-21 18:19:05 -07002268 else if (!strcmp(args[cur_arg], "agent-send")) {
2269 global.maxsock++;
2270 free(newsrv->agent.send_string);
2271 newsrv->agent.send_string_len = strlen(args[cur_arg + 1]);
2272 newsrv->agent.send_string = calloc(1, newsrv->agent.send_string_len + 1);
2273 memcpy(newsrv->agent.send_string, args[cur_arg + 1], newsrv->agent.send_string_len);
2274 cur_arg += 2;
2275 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002276 else if (!strcmp(args[cur_arg], "init-addr")) {
2277 char *p, *end;
2278 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002279 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002280
2281 newsrv->init_addr_methods = 0;
2282 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2283
2284 for (p = args[cur_arg + 1]; *p; p = end) {
2285 /* cut on next comma */
2286 for (end = p; *end && *end != ','; end++);
2287 if (*end)
2288 *(end++) = 0;
2289
Willy Tarreau4310d362016-11-02 15:05:56 +01002290 memset(&sa, 0, sizeof(sa));
Baptiste Assmann25938272016-09-21 20:26:16 +02002291 if (!strcmp(p, "libc")) {
2292 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2293 }
2294 else if (!strcmp(p, "last")) {
2295 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2296 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01002297 else if (!strcmp(p, "none")) {
2298 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2299 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002300 else if (str2ip2(p, &sa, 0)) {
2301 if (is_addr(&newsrv->init_addr)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002302 ha_alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
Willy Tarreau4310d362016-11-02 15:05:56 +01002303 file, linenum, args[cur_arg], p);
2304 err_code |= ERR_ALERT | ERR_FATAL;
2305 goto out;
2306 }
2307 newsrv->init_addr = sa;
2308 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2309 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002310 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002311 ha_alert("parsing [%s:%d]: '%s' : unknown init-addr method '%s', supported methods are 'libc', 'last', 'none'.\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002312 file, linenum, args[cur_arg], p);
2313 err_code |= ERR_ALERT | ERR_FATAL;
2314 goto out;
2315 }
2316 if (!done) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002317 ha_alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002318 file, linenum, args[cur_arg], p);
2319 err_code |= ERR_ALERT | ERR_FATAL;
2320 goto out;
2321 }
2322 }
2323 cur_arg += 2;
2324 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002325 else if (!strcmp(args[cur_arg], "resolvers")) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002326 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002327 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2328 cur_arg += 2;
2329 }
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002330 else if (!strcmp(args[cur_arg], "resolve-opts")) {
2331 char *p, *end;
2332
2333 for (p = args[cur_arg + 1]; *p; p = end) {
2334 /* cut on next comma */
2335 for (end = p; *end && *end != ','; end++);
2336 if (*end)
2337 *(end++) = 0;
2338
2339 if (!strcmp(p, "allow-dup-ip")) {
2340 newsrv->dns_opts.accept_duplicate_ip = 1;
2341 }
2342 else if (!strcmp(p, "prevent-dup-ip")) {
2343 newsrv->dns_opts.accept_duplicate_ip = 0;
2344 }
2345 else {
2346 ha_alert("parsing [%s:%d]: '%s' : unknown resolve-opts option '%s', supported methods are 'allow-dup-ip' and 'prevent-dup-ip'.\n",
2347 file, linenum, args[cur_arg], p);
2348 err_code |= ERR_ALERT | ERR_FATAL;
2349 goto out;
2350 }
2351 }
2352
2353 cur_arg += 2;
2354 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002355 else if (!strcmp(args[cur_arg], "resolve-prefer")) {
2356 if (!strcmp(args[cur_arg + 1], "ipv4"))
Thierry Fournierada34842016-02-17 21:25:09 +01002357 newsrv->dns_opts.family_prio = AF_INET;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002358 else if (!strcmp(args[cur_arg + 1], "ipv6"))
Thierry Fournierada34842016-02-17 21:25:09 +01002359 newsrv->dns_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002360 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002361 ha_alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002362 file, linenum, args[cur_arg]);
2363 err_code |= ERR_ALERT | ERR_FATAL;
2364 goto out;
2365 }
2366 cur_arg += 2;
2367 }
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002368 else if (!strcmp(args[cur_arg], "resolve-net")) {
2369 char *p, *e;
2370 unsigned char mask;
2371 struct dns_options *opt;
2372
2373 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002374 ha_alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002375 file, linenum, args[cur_arg]);
2376 err_code |= ERR_ALERT | ERR_FATAL;
2377 goto out;
2378 }
2379
2380 opt = &newsrv->dns_opts;
2381
2382 /* Split arguments by comma, and convert it from ipv4 or ipv6
2383 * string network in in_addr or in6_addr.
2384 */
2385 p = args[cur_arg + 1];
2386 e = p;
2387 while (*p != '\0') {
Joseph Herlant44466822018-11-15 08:57:51 -08002388 /* If no room available, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002389 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002390 ha_alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002391 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2392 err_code |= ERR_ALERT | ERR_FATAL;
2393 goto out;
2394 }
2395 /* look for end or comma. */
2396 while (*e != ',' && *e != '\0')
2397 e++;
2398 if (*e == ',') {
2399 *e = '\0';
2400 e++;
2401 }
2402 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2403 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2404 /* Try to convert input string from ipv4 or ipv6 network. */
2405 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2406 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2407 &mask)) {
2408 /* Try to convert input string from ipv6 network. */
2409 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2410 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2411 } else {
2412 /* All network conversions fail, retrun error. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002413 ha_alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002414 file, linenum, args[cur_arg], p);
2415 err_code |= ERR_ALERT | ERR_FATAL;
2416 goto out;
2417 }
2418 opt->pref_net_nb++;
2419 p = e;
2420 }
2421
2422 cur_arg += 2;
2423 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002424 else if (!strcmp(args[cur_arg], "rise")) {
2425 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002426 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002427 file, linenum, args[cur_arg]);
2428 err_code |= ERR_ALERT | ERR_FATAL;
2429 goto out;
2430 }
2431
2432 newsrv->check.rise = atol(args[cur_arg + 1]);
2433 if (newsrv->check.rise <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002434 ha_alert("parsing [%s:%d]: '%s' has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002435 file, linenum, args[cur_arg]);
2436 err_code |= ERR_ALERT | ERR_FATAL;
2437 goto out;
2438 }
2439
2440 if (newsrv->check.health)
2441 newsrv->check.health = newsrv->check.rise;
2442 cur_arg += 2;
2443 }
2444 else if (!strcmp(args[cur_arg], "fall")) {
2445 newsrv->check.fall = atol(args[cur_arg + 1]);
2446
2447 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002448 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002449 file, linenum, args[cur_arg]);
2450 err_code |= ERR_ALERT | ERR_FATAL;
2451 goto out;
2452 }
2453
2454 if (newsrv->check.fall <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002455 ha_alert("parsing [%s:%d]: '%s' has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002456 file, linenum, args[cur_arg]);
2457 err_code |= ERR_ALERT | ERR_FATAL;
2458 goto out;
2459 }
2460
2461 cur_arg += 2;
2462 }
2463 else if (!strcmp(args[cur_arg], "inter")) {
2464 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2465 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002466 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'inter' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002467 file, linenum, *err, newsrv->id);
2468 err_code |= ERR_ALERT | ERR_FATAL;
2469 goto out;
2470 }
2471 if (val <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002472 ha_alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002473 file, linenum, val, args[cur_arg], newsrv->id);
2474 err_code |= ERR_ALERT | ERR_FATAL;
2475 goto out;
2476 }
2477 newsrv->check.inter = val;
2478 cur_arg += 2;
2479 }
2480 else if (!strcmp(args[cur_arg], "fastinter")) {
2481 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2482 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002483 ha_alert("parsing [%s:%d]: unexpected character '%c' in 'fastinter' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002484 file, linenum, *err, newsrv->id);
2485 err_code |= ERR_ALERT | ERR_FATAL;
2486 goto out;
2487 }
2488 if (val <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002489 ha_alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002490 file, linenum, val, args[cur_arg], newsrv->id);
2491 err_code |= ERR_ALERT | ERR_FATAL;
2492 goto out;
2493 }
2494 newsrv->check.fastinter = val;
2495 cur_arg += 2;
2496 }
2497 else if (!strcmp(args[cur_arg], "downinter")) {
2498 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2499 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002500 ha_alert("parsing [%s:%d]: unexpected character '%c' in 'downinter' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002501 file, linenum, *err, newsrv->id);
2502 err_code |= ERR_ALERT | ERR_FATAL;
2503 goto out;
2504 }
2505 if (val <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002506 ha_alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002507 file, linenum, val, args[cur_arg], newsrv->id);
2508 err_code |= ERR_ALERT | ERR_FATAL;
2509 goto out;
2510 }
2511 newsrv->check.downinter = val;
2512 cur_arg += 2;
2513 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002514 else if (!strcmp(args[cur_arg], "port")) {
2515 newsrv->check.port = atol(args[cur_arg + 1]);
Baptiste Assmann6b453f12016-08-11 23:12:18 +02002516 newsrv->flags |= SRV_F_CHECKPORT;
Willy Tarreau272adea2014-03-31 10:39:59 +02002517 cur_arg += 2;
2518 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002519 else if (!strcmp(args[cur_arg], "weight")) {
2520 int w;
2521 w = atol(args[cur_arg + 1]);
2522 if (w < 0 || w > SRV_UWGHT_MAX) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002523 ha_alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002524 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2525 err_code |= ERR_ALERT | ERR_FATAL;
2526 goto out;
2527 }
2528 newsrv->uweight = newsrv->iweight = w;
2529 cur_arg += 2;
2530 }
2531 else if (!strcmp(args[cur_arg], "minconn")) {
2532 newsrv->minconn = atol(args[cur_arg + 1]);
2533 cur_arg += 2;
2534 }
2535 else if (!strcmp(args[cur_arg], "maxconn")) {
2536 newsrv->maxconn = atol(args[cur_arg + 1]);
2537 cur_arg += 2;
2538 }
2539 else if (!strcmp(args[cur_arg], "maxqueue")) {
2540 newsrv->maxqueue = atol(args[cur_arg + 1]);
2541 cur_arg += 2;
2542 }
2543 else if (!strcmp(args[cur_arg], "slowstart")) {
2544 /* slowstart is stored in seconds */
2545 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
2546 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002547 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002548 file, linenum, *err, newsrv->id);
2549 err_code |= ERR_ALERT | ERR_FATAL;
2550 goto out;
2551 }
2552 newsrv->slowstart = (val + 999) / 1000;
2553 cur_arg += 2;
2554 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002555 else if (!strcmp(args[cur_arg], "on-error")) {
2556 if (!strcmp(args[cur_arg + 1], "fastinter"))
2557 newsrv->onerror = HANA_ONERR_FASTINTER;
2558 else if (!strcmp(args[cur_arg + 1], "fail-check"))
2559 newsrv->onerror = HANA_ONERR_FAILCHK;
2560 else if (!strcmp(args[cur_arg + 1], "sudden-death"))
2561 newsrv->onerror = HANA_ONERR_SUDDTH;
2562 else if (!strcmp(args[cur_arg + 1], "mark-down"))
2563 newsrv->onerror = HANA_ONERR_MARKDWN;
2564 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002565 ha_alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
Willy Tarreau272adea2014-03-31 10:39:59 +02002566 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2567 file, linenum, args[cur_arg], args[cur_arg + 1]);
2568 err_code |= ERR_ALERT | ERR_FATAL;
2569 goto out;
2570 }
2571
2572 cur_arg += 2;
2573 }
2574 else if (!strcmp(args[cur_arg], "on-marked-down")) {
2575 if (!strcmp(args[cur_arg + 1], "shutdown-sessions"))
2576 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2577 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002578 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002579 file, linenum, args[cur_arg], args[cur_arg + 1]);
2580 err_code |= ERR_ALERT | ERR_FATAL;
2581 goto out;
2582 }
2583
2584 cur_arg += 2;
2585 }
2586 else if (!strcmp(args[cur_arg], "on-marked-up")) {
2587 if (!strcmp(args[cur_arg + 1], "shutdown-backup-sessions"))
2588 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2589 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002590 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002591 file, linenum, args[cur_arg], args[cur_arg + 1]);
2592 err_code |= ERR_ALERT | ERR_FATAL;
2593 goto out;
2594 }
2595
2596 cur_arg += 2;
2597 }
2598 else if (!strcmp(args[cur_arg], "error-limit")) {
2599 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002600 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002601 file, linenum, args[cur_arg]);
2602 err_code |= ERR_ALERT | ERR_FATAL;
2603 goto out;
2604 }
2605
2606 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2607
2608 if (newsrv->consecutive_errors_limit <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002609 ha_alert("parsing [%s:%d]: %s has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002610 file, linenum, args[cur_arg]);
2611 err_code |= ERR_ALERT | ERR_FATAL;
2612 goto out;
2613 }
2614 cur_arg += 2;
2615 }
Frédéric Lécaille8d083ed2017-04-14 15:19:56 +02002616 else if (!strcmp(args[cur_arg], "usesrc")) { /* address to use outside: needs "source" first */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002617 ha_alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002618 file, linenum, "usesrc", "source");
2619 err_code |= ERR_ALERT | ERR_FATAL;
2620 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002621 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002622 else {
2623 static int srv_dumped;
2624 struct srv_kw *kw;
2625 char *err;
2626
2627 kw = srv_find_kw(args[cur_arg]);
2628 if (kw) {
2629 char *err = NULL;
2630 int code;
2631
2632 if (!kw->parse) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002633 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not implemented in this version (check build options).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002634 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002635 if (kw->skip != -1)
2636 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002637 err_code |= ERR_ALERT | ERR_FATAL;
2638 goto out;
2639 }
2640
2641 if (defsrv && !kw->default_ok) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002642 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002643 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002644 if (kw->skip != -1)
2645 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002646 err_code |= ERR_ALERT;
2647 continue;
2648 }
2649
2650 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2651 err_code |= code;
2652
2653 if (code) {
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01002654 display_parser_err(file, linenum, args, cur_arg, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002655 if (code & ERR_FATAL) {
2656 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002657 if (kw->skip != -1)
2658 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002659 goto out;
2660 }
2661 }
2662 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002663 if (kw->skip != -1)
2664 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002665 continue;
2666 }
2667
2668 err = NULL;
2669 if (!srv_dumped) {
2670 srv_dump_kws(&err);
2671 indent_msg(&err, 4);
2672 srv_dumped = 1;
2673 }
2674
Christopher Faulet767a84b2017-11-24 16:50:31 +01002675 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002676 file, linenum, args[0], args[1], args[cur_arg],
2677 err ? " Registered keywords :" : "", err ? err : "");
2678 free(err);
2679
2680 err_code |= ERR_ALERT | ERR_FATAL;
2681 goto out;
2682 }
2683 }
2684
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002685 if (!defsrv)
2686 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2687 if (err_code & ERR_FATAL)
2688 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002689 if (srv_tmpl)
2690 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002691 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002692 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002693 return 0;
2694
2695 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002696 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002697 free(errmsg);
2698 return err_code;
2699}
2700
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002701/* Returns a pointer to the first server matching either id <id>.
2702 * NULL is returned if no match is found.
2703 * the lookup is performed in the backend <bk>
2704 */
2705struct server *server_find_by_id(struct proxy *bk, int id)
2706{
2707 struct eb32_node *eb32;
2708 struct server *curserver;
2709
2710 if (!bk || (id ==0))
2711 return NULL;
2712
2713 /* <bk> has no backend capabilities, so it can't have a server */
2714 if (!(bk->cap & PR_CAP_BE))
2715 return NULL;
2716
2717 curserver = NULL;
2718
2719 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2720 if (eb32)
2721 curserver = container_of(eb32, struct server, conf.id);
2722
2723 return curserver;
2724}
2725
2726/* Returns a pointer to the first server matching either name <name>, or id
2727 * if <name> starts with a '#'. NULL is returned if no match is found.
2728 * the lookup is performed in the backend <bk>
2729 */
2730struct server *server_find_by_name(struct proxy *bk, const char *name)
2731{
2732 struct server *curserver;
2733
2734 if (!bk || !name)
2735 return NULL;
2736
2737 /* <bk> has no backend capabilities, so it can't have a server */
2738 if (!(bk->cap & PR_CAP_BE))
2739 return NULL;
2740
2741 curserver = NULL;
2742 if (*name == '#') {
2743 curserver = server_find_by_id(bk, atoi(name + 1));
2744 if (curserver)
2745 return curserver;
2746 }
2747 else {
2748 curserver = bk->srv;
2749
2750 while (curserver && (strcmp(curserver->id, name) != 0))
2751 curserver = curserver->next;
2752
2753 if (curserver)
2754 return curserver;
2755 }
2756
2757 return NULL;
2758}
2759
2760struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2761{
2762 struct server *byname;
2763 struct server *byid;
2764
2765 if (!name && !id)
2766 return NULL;
2767
2768 if (diff)
2769 *diff = 0;
2770
2771 byname = byid = NULL;
2772
2773 if (name) {
2774 byname = server_find_by_name(bk, name);
2775 if (byname && (!id || byname->puid == id))
2776 return byname;
2777 }
2778
2779 /* remaining possibilities :
2780 * - name not set
2781 * - name set but not found
2782 * - name found but ID doesn't match
2783 */
2784 if (id) {
2785 byid = server_find_by_id(bk, id);
2786 if (byid) {
2787 if (byname) {
2788 /* use id only if forced by configuration */
2789 if (byid->flags & SRV_F_FORCED_ID) {
2790 if (diff)
2791 *diff |= 2;
2792 return byid;
2793 }
2794 else {
2795 if (diff)
2796 *diff |= 1;
2797 return byname;
2798 }
2799 }
2800
2801 /* remaining possibilities:
2802 * - name not set
2803 * - name set but not found
2804 */
2805 if (name && diff)
2806 *diff |= 2;
2807 return byid;
2808 }
2809
2810 /* id bot found */
2811 if (byname) {
2812 if (diff)
2813 *diff |= 1;
2814 return byname;
2815 }
2816 }
2817
2818 return NULL;
2819}
2820
Willy Tarreau46b7f532018-08-21 11:54:26 +02002821/* Update a server state using the parameters available in the params list.
2822 *
2823 * Grabs the server lock during operation.
2824 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002825static void srv_update_state(struct server *srv, int version, char **params)
2826{
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002827 char *p;
Willy Tarreau83061a82018-07-13 11:56:34 +02002828 struct buffer *msg;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002829
2830 /* fields since version 1
2831 * and common to all other upcoming versions
2832 */
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002833 enum srv_state srv_op_state;
2834 enum srv_admin srv_admin_state;
2835 unsigned srv_uweight, srv_iweight;
2836 unsigned long srv_last_time_change;
2837 short srv_check_status;
2838 enum chk_result srv_check_result;
2839 int srv_check_health;
2840 int srv_check_state, srv_agent_state;
2841 int bk_f_forced_id;
2842 int srv_f_forced_id;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002843 int fqdn_set_by_cli;
2844 const char *fqdn;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002845 const char *port_str;
2846 unsigned int port;
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002847 char *srvrecord;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002848
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002849 fqdn = NULL;
Frédéric Lécaille31694712017-08-01 08:47:19 +02002850 port = 0;
Willy Tarreau31138fa2015-09-29 18:38:47 +02002851 msg = get_trash_chunk();
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002852 switch (version) {
2853 case 1:
2854 /*
2855 * now we can proceed with server's state update:
2856 * srv_addr: params[0]
2857 * srv_op_state: params[1]
2858 * srv_admin_state: params[2]
2859 * srv_uweight: params[3]
2860 * srv_iweight: params[4]
2861 * srv_last_time_change: params[5]
2862 * srv_check_status: params[6]
2863 * srv_check_result: params[7]
2864 * srv_check_health: params[8]
2865 * srv_check_state: params[9]
2866 * srv_agent_state: params[10]
2867 * bk_f_forced_id: params[11]
2868 * srv_f_forced_id: params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002869 * srv_fqdn: params[13]
Frédéric Lécaille31694712017-08-01 08:47:19 +02002870 * srv_port: params[14]
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02002871 * srvrecord: params[15]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002872 */
2873
2874 /* validating srv_op_state */
2875 p = NULL;
2876 errno = 0;
2877 srv_op_state = strtol(params[1], &p, 10);
2878 if ((p == params[1]) || errno == EINVAL || errno == ERANGE ||
2879 (srv_op_state != SRV_ST_STOPPED &&
2880 srv_op_state != SRV_ST_STARTING &&
2881 srv_op_state != SRV_ST_RUNNING &&
2882 srv_op_state != SRV_ST_STOPPING)) {
2883 chunk_appendf(msg, ", invalid srv_op_state value '%s'", params[1]);
2884 }
2885
2886 /* validating srv_admin_state */
2887 p = NULL;
2888 errno = 0;
2889 srv_admin_state = strtol(params[2], &p, 10);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002890 fqdn_set_by_cli = !!(srv_admin_state & SRV_ADMF_HMAINT);
Willy Tarreau757478e2016-11-03 19:22:19 +01002891
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002892 /* inherited statuses will be recomputed later.
2893 * Also disable SRV_ADMF_HMAINT flag (set from stats socket fqdn).
2894 */
2895 srv_admin_state &= ~SRV_ADMF_IDRAIN & ~SRV_ADMF_IMAINT & ~SRV_ADMF_HMAINT;
Willy Tarreau757478e2016-11-03 19:22:19 +01002896
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002897 if ((p == params[2]) || errno == EINVAL || errno == ERANGE ||
2898 (srv_admin_state != 0 &&
2899 srv_admin_state != SRV_ADMF_FMAINT &&
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002900 srv_admin_state != SRV_ADMF_CMAINT &&
2901 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT) &&
Willy Tarreaue1bde142016-11-03 18:33:25 +01002902 srv_admin_state != (SRV_ADMF_CMAINT | SRV_ADMF_FDRAIN) &&
Willy Tarreau757478e2016-11-03 19:22:19 +01002903 srv_admin_state != SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002904 chunk_appendf(msg, ", invalid srv_admin_state value '%s'", params[2]);
2905 }
2906
2907 /* validating srv_uweight */
2908 p = NULL;
2909 errno = 0;
2910 srv_uweight = strtol(params[3], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002911 if ((p == params[3]) || errno == EINVAL || errno == ERANGE || (srv_uweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002912 chunk_appendf(msg, ", invalid srv_uweight value '%s'", params[3]);
2913
2914 /* validating srv_iweight */
2915 p = NULL;
2916 errno = 0;
2917 srv_iweight = strtol(params[4], &p, 10);
Willy Tarreaue1aebb22015-09-29 18:32:57 +02002918 if ((p == params[4]) || errno == EINVAL || errno == ERANGE || (srv_iweight > SRV_UWGHT_MAX))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002919 chunk_appendf(msg, ", invalid srv_iweight value '%s'", params[4]);
2920
2921 /* validating srv_last_time_change */
2922 p = NULL;
2923 errno = 0;
2924 srv_last_time_change = strtol(params[5], &p, 10);
2925 if ((p == params[5]) || errno == EINVAL || errno == ERANGE)
2926 chunk_appendf(msg, ", invalid srv_last_time_change value '%s'", params[5]);
2927
2928 /* validating srv_check_status */
2929 p = NULL;
2930 errno = 0;
2931 srv_check_status = strtol(params[6], &p, 10);
2932 if (p == params[6] || errno == EINVAL || errno == ERANGE ||
2933 (srv_check_status >= HCHK_STATUS_SIZE))
2934 chunk_appendf(msg, ", invalid srv_check_status value '%s'", params[6]);
2935
2936 /* validating srv_check_result */
2937 p = NULL;
2938 errno = 0;
2939 srv_check_result = strtol(params[7], &p, 10);
2940 if ((p == params[7]) || errno == EINVAL || errno == ERANGE ||
2941 (srv_check_result != CHK_RES_UNKNOWN &&
2942 srv_check_result != CHK_RES_NEUTRAL &&
2943 srv_check_result != CHK_RES_FAILED &&
2944 srv_check_result != CHK_RES_PASSED &&
2945 srv_check_result != CHK_RES_CONDPASS)) {
2946 chunk_appendf(msg, ", invalid srv_check_result value '%s'", params[7]);
2947 }
2948
2949 /* validating srv_check_health */
2950 p = NULL;
2951 errno = 0;
2952 srv_check_health = strtol(params[8], &p, 10);
2953 if (p == params[8] || errno == EINVAL || errno == ERANGE)
2954 chunk_appendf(msg, ", invalid srv_check_health value '%s'", params[8]);
2955
2956 /* validating srv_check_state */
2957 p = NULL;
2958 errno = 0;
2959 srv_check_state = strtol(params[9], &p, 10);
2960 if (p == params[9] || errno == EINVAL || errno == ERANGE ||
2961 (srv_check_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2962 chunk_appendf(msg, ", invalid srv_check_state value '%s'", params[9]);
2963
2964 /* validating srv_agent_state */
2965 p = NULL;
2966 errno = 0;
2967 srv_agent_state = strtol(params[10], &p, 10);
2968 if (p == params[10] || errno == EINVAL || errno == ERANGE ||
2969 (srv_agent_state & ~(CHK_ST_INPROGRESS | CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_PAUSED | CHK_ST_AGENT)))
2970 chunk_appendf(msg, ", invalid srv_agent_state value '%s'", params[10]);
2971
2972 /* validating bk_f_forced_id */
2973 p = NULL;
2974 errno = 0;
2975 bk_f_forced_id = strtol(params[11], &p, 10);
2976 if (p == params[11] || errno == EINVAL || errno == ERANGE || !((bk_f_forced_id == 0) || (bk_f_forced_id == 1)))
2977 chunk_appendf(msg, ", invalid bk_f_forced_id value '%s'", params[11]);
2978
2979 /* validating srv_f_forced_id */
2980 p = NULL;
2981 errno = 0;
2982 srv_f_forced_id = strtol(params[12], &p, 10);
2983 if (p == params[12] || errno == EINVAL || errno == ERANGE || !((srv_f_forced_id == 0) || (srv_f_forced_id == 1)))
2984 chunk_appendf(msg, ", invalid srv_f_forced_id value '%s'", params[12]);
2985
Frédéric Lécailleb418c122017-04-26 11:24:02 +02002986 /* validating srv_fqdn */
2987 fqdn = params[13];
2988 if (fqdn && *fqdn == '-')
2989 fqdn = NULL;
2990 if (fqdn && (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn))) {
2991 chunk_appendf(msg, ", invalid srv_fqdn value '%s'", params[13]);
2992 fqdn = NULL;
2993 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002994
Frédéric Lécaille31694712017-08-01 08:47:19 +02002995 port_str = params[14];
2996 if (port_str) {
2997 port = strl2uic(port_str, strlen(port_str));
2998 if (port > USHRT_MAX) {
2999 chunk_appendf(msg, ", invalid srv_port value '%s'", port_str);
3000 port_str = NULL;
3001 }
3002 }
3003
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02003004 /* SRV record
3005 * NOTE: in HAProxy, SRV records must start with an underscore '_'
3006 */
3007 srvrecord = params[15];
3008 if (srvrecord && *srvrecord != '_')
3009 srvrecord = NULL;
3010
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003011 /* don't apply anything if one error has been detected */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003012 if (msg->data)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003013 goto out;
3014
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003015 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003016 /* recover operational state and apply it to this server
3017 * and all servers tracking this one */
Jérôme Magninf57afa42019-01-20 11:27:40 +01003018 srv->check.health = srv_check_health;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003019 switch (srv_op_state) {
3020 case SRV_ST_STOPPED:
3021 srv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02003022 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003023 break;
3024 case SRV_ST_STARTING:
Jérôme Magninf57afa42019-01-20 11:27:40 +01003025 /* If rise == 1 there is no STARTING state, let's switch to
3026 * RUNNING
3027 */
3028 if (srv->check.rise == 1) {
3029 srv->check.health = srv->check.rise + srv->check.fall - 1;
3030 srv_set_running(srv, "", NULL);
3031 break;
3032 }
3033 if (srv->check.health < 1 || srv->check.health >= srv->check.rise)
3034 srv->check.health = srv->check.rise - 1;
Emeric Brun52a91d32017-08-31 14:41:55 +02003035 srv->next_state = srv_op_state;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003036 break;
3037 case SRV_ST_STOPPING:
Jérôme Magninf57afa42019-01-20 11:27:40 +01003038 /* If fall == 1 there is no STOPPING state, let's switch to
3039 * STOPPED
3040 */
3041 if (srv->check.fall == 1) {
3042 srv->check.health = 0;
3043 srv_set_stopped(srv, "changed from server-state after a reload", NULL);
3044 break;
3045 }
3046 if (srv->check.health < srv->check.rise ||
3047 srv->check.health > srv->check.rise + srv->check.fall - 2)
3048 srv->check.health = srv->check.rise;
Emeric Brun5a133512017-10-19 14:42:30 +02003049 srv_set_stopping(srv, "changed from server-state after a reload", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003050 break;
3051 case SRV_ST_RUNNING:
3052 srv->check.health = srv->check.rise + srv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003053 srv_set_running(srv, "", NULL);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003054 break;
3055 }
3056
3057 /* When applying server state, the following rules apply:
3058 * - in case of a configuration change, we apply the setting from the new
3059 * configuration, regardless of old running state
3060 * - if no configuration change, we apply old running state only if old running
3061 * state is different from new configuration state
3062 */
3063 /* configuration has changed */
Emeric Brun52a91d32017-08-31 14:41:55 +02003064 if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->next_admin & SRV_ADMF_CMAINT)) {
3065 if (srv->next_admin & SRV_ADMF_CMAINT)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003066 srv_adm_set_maint(srv);
3067 else
3068 srv_adm_set_ready(srv);
3069 }
3070 /* configuration is the same, let's compate old running state and new conf state */
3071 else {
Emeric Brun52a91d32017-08-31 14:41:55 +02003072 if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003073 srv_adm_set_maint(srv);
Emeric Brun52a91d32017-08-31 14:41:55 +02003074 else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->next_admin & SRV_ADMF_CMAINT))
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003075 srv_adm_set_ready(srv);
3076 }
3077 /* apply drain mode if server is currently enabled */
Emeric Brun52a91d32017-08-31 14:41:55 +02003078 if (!(srv->next_admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003079 /* The SRV_ADMF_FDRAIN flag is inherited when srv->iweight is 0
Willy Tarreau22cace22016-11-03 18:19:49 +01003080 * (srv->iweight is the weight set up in configuration).
3081 * There are two possible reasons for FDRAIN to have been present :
3082 * - previous config weight was zero
3083 * - "set server b/s drain" was sent to the CLI
3084 *
3085 * In the first case, we simply want to drop this drain state
3086 * if the new weight is not zero anymore, meaning the administrator
3087 * has intentionally turned the weight back to a positive value to
3088 * enable the server again after an operation. In the second case,
3089 * the drain state was forced on the CLI regardless of the config's
3090 * weight so we don't want a change to the config weight to lose this
3091 * status. What this means is :
3092 * - if previous weight was 0 and new one is >0, drop the DRAIN state.
3093 * - if the previous weight was >0, keep it.
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003094 */
Willy Tarreau22cace22016-11-03 18:19:49 +01003095 if (srv_iweight > 0 || srv->iweight == 0)
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003096 srv_adm_set_drain(srv);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003097 }
3098
3099 srv->last_change = date.tv_sec - srv_last_time_change;
3100 srv->check.status = srv_check_status;
3101 srv->check.result = srv_check_result;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003102
3103 /* Only case we want to apply is removing ENABLED flag which could have been
3104 * done by the "disable health" command over the stats socket
3105 */
3106 if ((srv->check.state & CHK_ST_CONFIGURED) &&
3107 (srv_check_state & CHK_ST_CONFIGURED) &&
3108 !(srv_check_state & CHK_ST_ENABLED))
3109 srv->check.state &= ~CHK_ST_ENABLED;
3110
3111 /* Only case we want to apply is removing ENABLED flag which could have been
3112 * done by the "disable agent" command over the stats socket
3113 */
3114 if ((srv->agent.state & CHK_ST_CONFIGURED) &&
3115 (srv_agent_state & CHK_ST_CONFIGURED) &&
3116 !(srv_agent_state & CHK_ST_ENABLED))
3117 srv->agent.state &= ~CHK_ST_ENABLED;
3118
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02003119 /* We want to apply the previous 'running' weight (srv_uweight) only if there
3120 * was no change in the configuration: both previous and new iweight are equals
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003121 *
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02003122 * It means that a configuration file change has precedence over a unix socket change
3123 * for server's weight
3124 *
3125 * by default, HAProxy applies the following weight when parsing the configuration
3126 * srv->uweight = srv->iweight
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003127 */
Baptiste Assmann6076d1c2015-09-17 22:53:59 +02003128 if (srv_iweight == srv->iweight) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003129 srv->uweight = srv_uweight;
3130 }
Willy Tarreau3ff577e2018-08-02 11:48:52 +02003131 server_recalc_eweight(srv, 1);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003132
Willy Tarreaue5a60682016-11-09 14:54:53 +01003133 /* load server IP address */
Daniel Corbett9215ffa2018-05-19 19:43:24 -04003134 if (strcmp(params[0], "-"))
3135 srv->lastaddr = strdup(params[0]);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003136
3137 if (fqdn && srv->hostname) {
3138 if (!strcmp(srv->hostname, fqdn)) {
3139 /* Here we reset the 'set from stats socket FQDN' flag
3140 * to support such transitions:
3141 * Let's say initial FQDN value is foo1 (in configuration file).
3142 * - FQDN changed from stats socket, from foo1 to foo2 value,
3143 * - FQDN changed again from file configuration (with the same previous value
3144 set from stats socket, from foo1 to foo2 value),
3145 * - reload for any other reason than a FQDN modification,
3146 * the configuration file FQDN matches the fqdn server state file value.
3147 * So we must reset the 'set from stats socket FQDN' flag to be consistent with
Joseph Herlant44466822018-11-15 08:57:51 -08003148 * any further FQDN modification.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003149 */
Emeric Brun52a91d32017-08-31 14:41:55 +02003150 srv->next_admin &= ~SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003151 }
3152 else {
3153 /* If the FDQN has been changed from stats socket,
3154 * apply fqdn state file value (which is the value set
3155 * from stats socket).
3156 */
3157 if (fqdn_set_by_cli) {
Olivier Houchardd16bfe62017-10-31 15:21:19 +01003158 srv_set_fqdn(srv, fqdn, 0);
Emeric Brun52a91d32017-08-31 14:41:55 +02003159 srv->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003160 }
3161 }
3162 }
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02003163 /* If all the conditions below are validated, this means
3164 * we're evaluating a server managed by SRV resolution
3165 */
3166 else if (fqdn && !srv->hostname && srvrecord) {
3167 int res;
3168
3169 /* we can't apply previous state if SRV record has changed */
3170 if (srv->srvrq && strcmp(srv->srvrq->name, srvrecord) != 0) {
3171 chunk_appendf(msg, ", SRV record mismatch between configuration ('%s') and state file ('%s) for server '%s'. Previous state not applied", srv->srvrq->name, srvrecord, srv->id);
3172 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
3173 goto out;
3174 }
3175
3176 /* create or find a SRV resolution for this srv record */
3177 if (srv->srvrq == NULL && (srv->srvrq = find_srvrq_by_name(srvrecord, srv->proxy)) == NULL)
3178 srv->srvrq = new_dns_srvrq(srv, srvrecord);
3179 if (srv->srvrq == NULL) {
3180 chunk_appendf(msg, ", can't create or find SRV resolution '%s' for server '%s'", srvrecord, srv->id);
3181 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
3182 goto out;
3183 }
3184
3185 /* prepare DNS resolution for this server */
3186 res = srv_prepare_for_resolution(srv, fqdn);
3187 if (res == -1) {
3188 chunk_appendf(msg, ", can't allocate memory for DNS resolution for server '%s'", srv->id);
3189 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
3190 goto out;
3191 }
3192
3193 /* configure check.port accordingly */
3194 if ((srv->check.state & CHK_ST_CONFIGURED) &&
3195 !(srv->flags & SRV_F_CHECKPORT))
3196 srv->check.port = port;
3197
3198 /* Unset SRV_F_MAPPORTS for SRV records.
3199 * SRV_F_MAPPORTS is unfortunately set by parse_server()
3200 * because no ports are provided in the configuration file.
3201 * This is because HAProxy will use the port found into the SRV record.
3202 */
3203 srv->flags &= ~SRV_F_MAPPORTS;
3204 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003205
Frédéric Lécaille31694712017-08-01 08:47:19 +02003206 if (port_str)
3207 srv->svc_port = port;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003208 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Frédéric Lécaille31694712017-08-01 08:47:19 +02003209
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003210 break;
3211 default:
3212 chunk_appendf(msg, ", version '%d' not supported", version);
3213 }
3214
3215 out:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003216 if (msg->data) {
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003217 chunk_appendf(msg, "\n");
Christopher Faulet767a84b2017-11-24 16:50:31 +01003218 ha_warning("server-state application failed for server '%s/%s'%s",
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003219 srv->proxy->id, srv->id, msg->area);
Baptiste Assmann0821bb92016-01-21 00:20:50 +01003220 }
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003221}
3222
3223/* This function parses all the proxies and only take care of the backends (since we're looking for server)
3224 * For each proxy, it does the following:
3225 * - opens its server state file (either one or local one)
3226 * - read whole file, line by line
3227 * - analyse each line to check if it matches our current backend:
3228 * - backend name matches
3229 * - backend id matches if id is forced and name doesn't match
3230 * - if the server pointed by the line is found, then state is applied
3231 *
3232 * If the running backend uuid or id differs from the state file, then HAProxy reports
3233 * a warning.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003234 *
3235 * Grabs the server's lock via srv_update_state().
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003236 */
3237void apply_server_state(void)
3238{
3239 char *cur, *end;
3240 char mybuf[SRV_STATE_LINE_MAXLEN];
3241 int mybuflen;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003242 char *params[SRV_STATE_FILE_MAX_FIELDS] = {0};
3243 char *srv_params[SRV_STATE_FILE_MAX_FIELDS] = {0};
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003244 int arg, srv_arg, version, diff;
3245 FILE *f;
3246 char *filepath;
3247 char globalfilepath[MAXPATHLEN + 1];
3248 char localfilepath[MAXPATHLEN + 1];
3249 int len, fileopenerr, globalfilepathlen, localfilepathlen;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003250 struct proxy *curproxy, *bk;
3251 struct server *srv;
3252
3253 globalfilepathlen = 0;
3254 /* create the globalfilepath variable */
3255 if (global.server_state_file) {
3256 /* absolute path or no base directory provided */
3257 if ((global.server_state_file[0] == '/') || (!global.server_state_base)) {
3258 len = strlen(global.server_state_file);
3259 if (len > MAXPATHLEN) {
3260 globalfilepathlen = 0;
3261 goto globalfileerror;
3262 }
3263 memcpy(globalfilepath, global.server_state_file, len);
3264 globalfilepath[len] = '\0';
3265 globalfilepathlen = len;
3266 }
3267 else if (global.server_state_base) {
3268 len = strlen(global.server_state_base);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003269 if (len > MAXPATHLEN) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003270 globalfilepathlen = 0;
3271 goto globalfileerror;
3272 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003273 memcpy(globalfilepath, global.server_state_base, len);
Willy Tarreau5dfb6c42018-10-16 19:26:12 +02003274 globalfilepath[len] = 0;
3275 globalfilepathlen = len;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003276
3277 /* append a slash if needed */
3278 if (!globalfilepathlen || globalfilepath[globalfilepathlen - 1] != '/') {
3279 if (globalfilepathlen + 1 > MAXPATHLEN) {
3280 globalfilepathlen = 0;
3281 goto globalfileerror;
3282 }
3283 globalfilepath[globalfilepathlen++] = '/';
3284 }
3285
3286 len = strlen(global.server_state_file);
3287 if (globalfilepathlen + len > MAXPATHLEN) {
3288 globalfilepathlen = 0;
3289 goto globalfileerror;
3290 }
3291 memcpy(globalfilepath + globalfilepathlen, global.server_state_file, len);
3292 globalfilepathlen += len;
3293 globalfilepath[globalfilepathlen++] = 0;
3294 }
3295 }
3296 globalfileerror:
3297 if (globalfilepathlen == 0)
3298 globalfilepath[0] = '\0';
3299
3300 /* read servers state from local file */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003301 for (curproxy = proxies_list; curproxy != NULL; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003302 /* servers are only in backends */
3303 if (!(curproxy->cap & PR_CAP_BE))
3304 continue;
3305 fileopenerr = 0;
3306 filepath = NULL;
3307
3308 /* search server state file path and name */
3309 switch (curproxy->load_server_state_from_file) {
3310 /* read servers state from global file */
3311 case PR_SRV_STATE_FILE_GLOBAL:
3312 /* there was an error while generating global server state file path */
3313 if (globalfilepathlen == 0)
3314 continue;
3315 filepath = globalfilepath;
3316 fileopenerr = 1;
3317 break;
3318 /* this backend has its own file */
3319 case PR_SRV_STATE_FILE_LOCAL:
3320 localfilepathlen = 0;
3321 localfilepath[0] = '\0';
3322 len = 0;
3323 /* create the localfilepath variable */
3324 /* absolute path or no base directory provided */
3325 if ((curproxy->server_state_file_name[0] == '/') || (!global.server_state_base)) {
3326 len = strlen(curproxy->server_state_file_name);
3327 if (len > MAXPATHLEN) {
3328 localfilepathlen = 0;
3329 goto localfileerror;
3330 }
3331 memcpy(localfilepath, curproxy->server_state_file_name, len);
3332 localfilepath[len] = '\0';
3333 localfilepathlen = len;
3334 }
3335 else if (global.server_state_base) {
3336 len = strlen(global.server_state_base);
3337 localfilepathlen += len;
3338
3339 if (localfilepathlen > MAXPATHLEN) {
3340 localfilepathlen = 0;
3341 goto localfileerror;
3342 }
Olivier Houchard17f8b902018-10-16 18:35:01 +02003343 memcpy(localfilepath, global.server_state_base, len);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003344 localfilepath[localfilepathlen] = 0;
3345
3346 /* append a slash if needed */
3347 if (!localfilepathlen || localfilepath[localfilepathlen - 1] != '/') {
3348 if (localfilepathlen + 1 > MAXPATHLEN) {
3349 localfilepathlen = 0;
3350 goto localfileerror;
3351 }
3352 localfilepath[localfilepathlen++] = '/';
3353 }
3354
3355 len = strlen(curproxy->server_state_file_name);
3356 if (localfilepathlen + len > MAXPATHLEN) {
3357 localfilepathlen = 0;
3358 goto localfileerror;
3359 }
3360 memcpy(localfilepath + localfilepathlen, curproxy->server_state_file_name, len);
3361 localfilepathlen += len;
3362 localfilepath[localfilepathlen++] = 0;
3363 }
3364 filepath = localfilepath;
3365 localfileerror:
3366 if (localfilepathlen == 0)
3367 localfilepath[0] = '\0';
3368
3369 break;
3370 case PR_SRV_STATE_FILE_NONE:
3371 default:
3372 continue;
3373 }
3374
3375 /* preload global state file */
3376 errno = 0;
3377 f = fopen(filepath, "r");
3378 if (errno && fileopenerr)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003379 ha_warning("Can't open server state file '%s': %s\n", filepath, strerror(errno));
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003380 if (!f)
3381 continue;
3382
3383 mybuf[0] = '\0';
3384 mybuflen = 0;
3385 version = 0;
3386
3387 /* first character of first line of the file must contain the version of the export */
Dragan Dosencf4fb032015-11-04 23:03:26 +01003388 if (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003389 ha_warning("Can't read first line of the server state file '%s'\n", filepath);
Dragan Dosencf4fb032015-11-04 23:03:26 +01003390 goto fileclose;
3391 }
3392
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003393 cur = mybuf;
3394 version = atoi(cur);
3395 if ((version < SRV_STATE_FILE_VERSION_MIN) ||
3396 (version > SRV_STATE_FILE_VERSION_MAX))
Dragan Dosencf4fb032015-11-04 23:03:26 +01003397 goto fileclose;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003398
3399 while (fgets(mybuf, SRV_STATE_LINE_MAXLEN, f)) {
3400 int bk_f_forced_id = 0;
3401 int check_id = 0;
3402 int check_name = 0;
3403
3404 mybuflen = strlen(mybuf);
3405 cur = mybuf;
3406 end = cur + mybuflen;
3407
3408 bk = NULL;
3409 srv = NULL;
3410
3411 /* we need at least one character */
3412 if (mybuflen == 0)
3413 continue;
3414
3415 /* ignore blank characters at the beginning of the line */
3416 while (isspace(*cur))
3417 ++cur;
3418
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003419 /* Ignore empty or commented lines */
3420 if (cur == end || *cur == '#')
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003421 continue;
3422
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003423 /* truncated lines */
3424 if (mybuf[mybuflen - 1] != '\n') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003425 ha_warning("server-state file '%s': truncated line\n", filepath);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003426 continue;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003427 }
3428
3429 /* Removes trailing '\n' */
3430 mybuf[mybuflen - 1] = '\0';
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003431
3432 /* we're now ready to move the line into *srv_params[] */
3433 params[0] = cur;
3434 arg = 1;
3435 srv_arg = 0;
3436 while (*cur && arg < SRV_STATE_FILE_MAX_FIELDS) {
3437 if (isspace(*cur)) {
3438 *cur = '\0';
3439 ++cur;
3440 while (isspace(*cur))
3441 ++cur;
3442 switch (version) {
3443 case 1:
3444 /*
3445 * srv_addr: params[4] => srv_params[0]
3446 * srv_op_state: params[5] => srv_params[1]
3447 * srv_admin_state: params[6] => srv_params[2]
3448 * srv_uweight: params[7] => srv_params[3]
3449 * srv_iweight: params[8] => srv_params[4]
3450 * srv_last_time_change: params[9] => srv_params[5]
3451 * srv_check_status: params[10] => srv_params[6]
3452 * srv_check_result: params[11] => srv_params[7]
3453 * srv_check_health: params[12] => srv_params[8]
3454 * srv_check_state: params[13] => srv_params[9]
3455 * srv_agent_state: params[14] => srv_params[10]
3456 * bk_f_forced_id: params[15] => srv_params[11]
3457 * srv_f_forced_id: params[16] => srv_params[12]
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003458 * srv_fqdn: params[17] => srv_params[13]
Frédéric Lécaille31694712017-08-01 08:47:19 +02003459 * srv_port: params[18] => srv_params[14]
Baptiste Assmann6d0f38f2018-07-02 17:00:54 +02003460 * srvrecord: params[19] => srv_params[15]
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003461 */
3462 if (arg >= 4) {
3463 srv_params[srv_arg] = cur;
3464 ++srv_arg;
3465 }
3466 break;
3467 }
3468
3469 params[arg] = cur;
3470 ++arg;
3471 }
3472 else {
3473 ++cur;
3474 }
3475 }
3476
3477 /* if line is incomplete line, then ignore it.
3478 * otherwise, update useful flags */
3479 switch (version) {
3480 case 1:
3481 if (arg < SRV_STATE_FILE_NB_FIELDS_VERSION_1)
3482 continue;
3483 bk_f_forced_id = (atoi(params[15]) & PR_O_FORCED_ID);
3484 check_id = (atoi(params[0]) == curproxy->uuid);
3485 check_name = (strcmp(curproxy->id, params[1]) == 0);
3486 break;
3487 }
3488
3489 diff = 0;
3490 bk = curproxy;
3491
3492 /* if backend can't be found, let's continue */
3493 if (!check_id && !check_name)
3494 continue;
3495 else if (!check_id && check_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003496 ha_warning("backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003497 send_log(bk, LOG_NOTICE, "backend ID mismatch: from server state file: '%s', from running config '%d'\n", params[0], bk->uuid);
3498 }
3499 else if (check_id && !check_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003500 ha_warning("backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003501 send_log(bk, LOG_NOTICE, "backend name mismatch: from server state file: '%s', from running config '%s'\n", params[1], bk->id);
3502 /* if name doesn't match, we still want to update curproxy if the backend id
3503 * was forced in previous the previous configuration */
3504 if (!bk_f_forced_id)
3505 continue;
3506 }
3507
3508 /* look for the server by its id: param[2] */
3509 /* else look for the server by its name: param[3] */
3510 diff = 0;
3511 srv = server_find_best_match(bk, params[3], atoi(params[2]), &diff);
3512
3513 if (!srv) {
3514 /* if no server found, then warning and continue with next line */
Christopher Faulet767a84b2017-11-24 16:50:31 +01003515 ha_warning("can't find server '%s' with id '%s' in backend with id '%s' or name '%s'\n",
3516 params[3], params[2], params[0], params[1]);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003517 send_log(bk, LOG_NOTICE, "can't find server '%s' with id '%s' in backend with id '%s' or name '%s'\n",
3518 params[3], params[2], params[0], params[1]);
3519 continue;
3520 }
3521 else if (diff & PR_FBM_MISMATCH_ID) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003522 ha_warning("In backend '%s' (id: '%d'): server ID mismatch: from server state file: '%s', from running config %d\n", bk->id, bk->uuid, params[2], srv->puid);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003523 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 +02003524 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003525 }
3526 else if (diff & PR_FBM_MISMATCH_NAME) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003527 ha_warning("In backend '%s' (id: %d): server name mismatch: from server state file: '%s', from running config '%s'\n", bk->id, bk->uuid, params[3], srv->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003528 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 +02003529 continue;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003530 }
3531
3532 /* now we can proceed with server's state update */
3533 srv_update_state(srv, version, srv_params);
3534 }
Dragan Dosencf4fb032015-11-04 23:03:26 +01003535fileclose:
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003536 fclose(f);
3537 }
3538}
3539
Simon Horman7d09b9a2013-02-12 10:45:51 +09003540/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02003541 * update a server's current IP address.
3542 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
3543 * ip is in network format.
3544 * updater is a string which contains an information about the requester of the update.
3545 * updater is used if not NULL.
3546 *
3547 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003548 *
3549 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02003550 */
Thierry Fournierd35b7a62016-02-24 08:23:22 +01003551int update_server_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02003552{
3553 /* generates a log line and a warning on stderr */
3554 if (1) {
3555 /* book enough space for both IPv4 and IPv6 */
3556 char oldip[INET6_ADDRSTRLEN];
3557 char newip[INET6_ADDRSTRLEN];
3558
3559 memset(oldip, '\0', INET6_ADDRSTRLEN);
3560 memset(newip, '\0', INET6_ADDRSTRLEN);
3561
3562 /* copy old IP address in a string */
3563 switch (s->addr.ss_family) {
3564 case AF_INET:
3565 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
3566 break;
3567 case AF_INET6:
3568 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
3569 break;
3570 };
3571
3572 /* copy new IP address in a string */
3573 switch (ip_sin_family) {
3574 case AF_INET:
3575 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
3576 break;
3577 case AF_INET6:
3578 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
3579 break;
3580 };
3581
3582 /* save log line into a buffer */
3583 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
3584 s->proxy->id, s->id, oldip, newip, updater);
3585
3586 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003587 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003588
3589 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003590 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003591 }
3592
3593 /* save the new IP family */
3594 s->addr.ss_family = ip_sin_family;
3595 /* save the new IP address */
3596 switch (ip_sin_family) {
3597 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02003598 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003599 break;
3600 case AF_INET6:
3601 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
3602 break;
3603 };
Olivier Houchard4e694042017-03-14 20:01:29 +01003604 srv_set_dyncookie(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02003605
3606 return 0;
3607}
3608
3609/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003610 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
3611 *
3612 * Caller can pass its name through <updater> to get it integrated in the response message
3613 * returned by the function.
3614 *
3615 * The function first does the following, in that order:
3616 * - validates the new addr and/or port
3617 * - checks if an update is required (new IP or port is different than current ones)
3618 * - checks the update is allowed:
3619 * - don't switch from/to a family other than AF_INET4 and AF_INET6
3620 * - allow all changes if no CHECKS are configured
3621 * - if CHECK is configured:
3622 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
3623 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
3624 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02003625 *
3626 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003627 */
3628const char *update_server_addr_port(struct server *s, const char *addr, const char *port, char *updater)
3629{
3630 struct sockaddr_storage sa;
3631 int ret, port_change_required;
3632 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00003633 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02003634 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01003635 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003636
3637 msg = get_trash_chunk();
3638 chunk_reset(msg);
3639
3640 if (addr) {
3641 memset(&sa, 0, sizeof(struct sockaddr_storage));
3642 if (str2ip2(addr, &sa, 0) == NULL) {
3643 chunk_printf(msg, "Invalid addr '%s'", addr);
3644 goto out;
3645 }
3646
3647 /* changes are allowed on AF_INET* families only */
3648 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
3649 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
3650 goto out;
3651 }
3652
3653 /* collecting data currently setup */
3654 memset(current_addr, '\0', sizeof(current_addr));
3655 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
3656 /* changes are allowed on AF_INET* families only */
3657 if ((ret != AF_INET) && (ret != AF_INET6)) {
3658 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
3659 goto out;
3660 }
3661
3662 /* applying ADDR changes if required and allowed
3663 * ipcmp returns 0 when both ADDR are the same
3664 */
3665 if (ipcmp(&s->addr, &sa) == 0) {
3666 chunk_appendf(msg, "no need to change the addr");
3667 goto port;
3668 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003669 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01003670 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003671
3672 /* we also need to update check's ADDR only if it uses the server's one */
3673 if ((s->check.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_CHECKADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003674 ipcpy(&sa, &s->check.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003675 }
3676
3677 /* we also need to update agent ADDR only if it use the server's one */
3678 if ((s->agent.state & CHK_ST_CONFIGURED) && (s->flags & SRV_F_AGENTADDR)) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003679 ipcpy(&sa, &s->agent.addr);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003680 }
3681
3682 /* update report for caller */
3683 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
3684 }
3685
3686 port:
3687 if (port) {
3688 char sign = '\0';
3689 char *endptr;
3690
3691 if (addr)
3692 chunk_appendf(msg, ", ");
3693
3694 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01003695 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003696
3697 /* check if PORT change is required */
3698 port_change_required = 0;
3699
3700 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04003701 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003702 new_port = strtol(port, &endptr, 10);
3703 if ((errno != 0) || (port == endptr)) {
3704 chunk_appendf(msg, "problem converting port '%s' to an int", port);
3705 goto out;
3706 }
3707
3708 /* check if caller triggers a port mapped or offset */
3709 if (sign == '-' || (sign == '+')) {
3710 /* check if server currently uses port map */
3711 if (!(s->flags & SRV_F_MAPPORTS)) {
3712 /* switch from fixed port to port map mandatorily triggers
3713 * a port change */
3714 port_change_required = 1;
3715 /* check is configured
3716 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
3717 * prevent PORT change if check doesn't have it's dedicated port while switching
3718 * to port mapping */
3719 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3720 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.");
3721 goto out;
3722 }
3723 }
3724 /* we're already using port maps */
3725 else {
3726 port_change_required = current_port != new_port;
3727 }
3728 }
3729 /* fixed port */
3730 else {
3731 port_change_required = current_port != new_port;
3732 }
3733
3734 /* applying PORT changes if required and update response message */
3735 if (port_change_required) {
3736 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01003737 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01003738 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003739
3740 /* prepare message */
3741 chunk_appendf(msg, "port changed from '");
3742 if (s->flags & SRV_F_MAPPORTS)
3743 chunk_appendf(msg, "+");
3744 chunk_appendf(msg, "%d' to '", current_port);
3745
3746 if (sign == '-') {
3747 s->flags |= SRV_F_MAPPORTS;
3748 chunk_appendf(msg, "%c", sign);
3749 /* just use for result output */
3750 new_port = -new_port;
3751 }
3752 else if (sign == '+') {
3753 s->flags |= SRV_F_MAPPORTS;
3754 chunk_appendf(msg, "%c", sign);
3755 }
3756 else {
3757 s->flags &= ~SRV_F_MAPPORTS;
3758 }
3759
3760 chunk_appendf(msg, "%d'", new_port);
3761
3762 /* we also need to update health checks port only if it uses server's realport */
3763 if ((s->check.state & CHK_ST_CONFIGURED) && !(s->flags & SRV_F_CHECKPORT)) {
3764 s->check.port = new_port;
3765 }
3766 }
3767 else {
3768 chunk_appendf(msg, "no need to change the port");
3769 }
3770 }
3771
3772out:
Olivier Houchard4e694042017-03-14 20:01:29 +01003773 if (changed)
3774 srv_set_dyncookie(s);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003775 if (updater)
3776 chunk_appendf(msg, " by '%s'", updater);
3777 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003778 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02003779}
3780
3781
3782/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003783 * update server status based on result of name resolution
3784 * returns:
3785 * 0 if server status is updated
3786 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02003787 *
3788 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003789 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003790int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003791{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003792 struct dns_resolvers *resolvers = s->resolvers;
3793 struct dns_resolution *resolution = s->dns_requester->resolution;
3794 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003795
3796 switch (resolution->status) {
3797 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003798 /* status when HAProxy has just (re)started.
3799 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003800 break;
3801
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003802 case RSLV_STATUS_VALID:
3803 /*
3804 * resume health checks
3805 * server will be turned back on if health check is safe
3806 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003807 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02003808 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003809 return 1;
3810 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
3811 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02003812 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003813 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02003814
Emeric Brun52a91d32017-08-31 14:41:55 +02003815 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003816 return 1;
3817 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
3818 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
3819 s->proxy->id, s->id);
3820
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003821 ha_warning("%s.\n", trash.area);
3822 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003823 return 0;
3824
3825 case RSLV_STATUS_NX:
3826 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003827 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
3828 if (!tick_is_expired(exp, now_ms))
3829 break;
3830
3831 if (s->next_admin & SRV_ADMF_RMAINT)
3832 return 1;
3833 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3834 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003835
3836 case RSLV_STATUS_TIMEOUT:
3837 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003838 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3839 if (!tick_is_expired(exp, now_ms))
3840 break;
3841
3842 if (s->next_admin & SRV_ADMF_RMAINT)
3843 return 1;
3844 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3845 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003846
3847 case RSLV_STATUS_REFUSED:
3848 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003849 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3850 if (!tick_is_expired(exp, now_ms))
3851 break;
3852
3853 if (s->next_admin & SRV_ADMF_RMAINT)
3854 return 1;
3855 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3856 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003857
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003858 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003859 /* stop server if resolution failed for a long enough period */
3860 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3861 if (!tick_is_expired(exp, now_ms))
3862 break;
3863
3864 if (s->next_admin & SRV_ADMF_RMAINT)
3865 return 1;
3866 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3867 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003868 }
3869
3870 return 1;
3871}
3872
3873/*
3874 * Server Name Resolution valid response callback
3875 * It expects:
3876 * - <nameserver>: the name server which answered the valid response
3877 * - <response>: buffer containing a valid DNS response
3878 * - <response_len>: size of <response>
3879 * It performs the following actions:
3880 * - ignore response if current ip found and server family not met
3881 * - update with first new ip found if family is met and current IP is not found
3882 * returns:
3883 * 0 on error
3884 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003885 *
3886 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003887 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003888int snr_resolution_cb(struct dns_requester *requester, struct dns_nameserver *nameserver)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003889{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003890 struct server *s = NULL;
3891 struct dns_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003892 void *serverip, *firstip;
3893 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003894 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003895 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003896 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003897
Christopher Faulet67957bd2017-09-27 11:00:59 +02003898 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003899 if (!s)
3900 return 1;
3901
Christopher Faulet67957bd2017-09-27 11:00:59 +02003902 resolution = s->dns_requester->resolution;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003903
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003904 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003905 firstip = NULL; /* pointer to the first valid response found */
3906 /* it will be used as the new IP if a change is required */
3907 firstip_sin_family = AF_UNSPEC;
3908 serverip = NULL; /* current server IP address */
3909
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003910 /* initializing server IP pointer */
3911 server_sin_family = s->addr.ss_family;
3912 switch (server_sin_family) {
3913 case AF_INET:
3914 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3915 break;
3916
3917 case AF_INET6:
3918 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3919 break;
3920
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003921 case AF_UNSPEC:
3922 break;
3923
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003924 default:
3925 goto invalid;
3926 }
3927
Baptiste Assmann729c9012017-05-22 15:13:10 +02003928 ret = dns_get_ip_from_response(&resolution->response, &s->dns_opts,
Thierry Fournierada34842016-02-17 21:25:09 +01003929 serverip, server_sin_family, &firstip,
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003930 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003931
3932 switch (ret) {
3933 case DNS_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003934 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003935
3936 case DNS_UPD_SRVIP_NOT_FOUND:
3937 goto save_ip;
3938
3939 case DNS_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003940 goto invalid;
3941
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003942 case DNS_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003943 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003944 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003945
Baptiste Assmannfad03182015-10-28 02:03:32 +01003946 case DNS_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003947 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003948 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003949 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003950
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003951 default:
3952 goto invalid;
3953
3954 }
3955
3956 save_ip:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003957 if (nameserver) {
3958 nameserver->counters.update++;
3959 /* save the first ip we found */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003960 chunk_printf(chk, "%s/%s", nameserver->resolvers->id, nameserver->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003961 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003962 else
3963 chunk_printf(chk, "DNS cache");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003964 update_server_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003965
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003966 update_status:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003967 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003968 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003969
3970 invalid:
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003971 if (nameserver) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02003972 nameserver->counters.invalid++;
3973 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003974 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003975 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003976 return 0;
3977}
3978
3979/*
3980 * Server Name Resolution error management callback
3981 * returns:
3982 * 0 on error
3983 * 1 when no error or safe ignore
Willy Tarreau46b7f532018-08-21 11:54:26 +02003984 *
3985 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003986 */
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003987int snr_resolution_error_cb(struct dns_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003988{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003989 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003990
Christopher Faulet67957bd2017-09-27 11:00:59 +02003991 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003992 if (!s)
3993 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003994 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003995 snr_update_srv_status(s, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003996 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003997 return 1;
3998}
3999
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004000/*
4001 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004002 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004003 * It returns a pointer to the first server found or NULL if <ip> is not yet
4004 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01004005 *
4006 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004007 */
4008struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
4009{
4010 struct server *tmpsrv;
4011 struct proxy *be;
4012
4013 if (!srv)
4014 return NULL;
4015
4016 be = srv->proxy;
4017 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01004018 /* we found the current server is the same, ignore it */
4019 if (srv == tmpsrv)
4020 continue;
4021
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004022 /* We want to compare the IP in the record with the IP of the servers in the
4023 * same backend, only if:
4024 * * DNS resolution is enabled on the server
4025 * * the hostname used for the resolution by our server is the same than the
4026 * one used for the server found in the backend
4027 * * the server found in the backend is not our current server
4028 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004029 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004030 if ((tmpsrv->hostname_dn == NULL) ||
4031 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
4032 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01004033 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004034 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004035 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01004036 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004037
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004038 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01004039 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004040 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004041 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01004042 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02004043
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004044 /* At this point, we have 2 different servers using the same DNS hostname
4045 * for their respective resolution.
4046 */
4047 if (*ip_family == tmpsrv->addr.ss_family &&
4048 ((tmpsrv->addr.ss_family == AF_INET &&
4049 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
4050 (tmpsrv->addr.ss_family == AF_INET6 &&
4051 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004052 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004053 return tmpsrv;
4054 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004055 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004056 }
4057
Emeric Brune9fd6b52017-11-02 17:20:39 +01004058
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02004059 return NULL;
4060}
4061
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004062/* Sets the server's address (srv->addr) from srv->hostname using the libc's
4063 * resolver. This is suited for initial address configuration. Returns 0 on
4064 * success otherwise a non-zero error code. In case of error, *err_code, if
4065 * not NULL, is filled up.
4066 */
4067int srv_set_addr_via_libc(struct server *srv, int *err_code)
4068{
4069 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004070 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01004071 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004072 return 1;
4073 }
4074 return 0;
4075}
4076
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004077/* Set the server's FDQN (->hostname) from <hostname>.
4078 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004079 *
4080 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004081 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004082int srv_set_fqdn(struct server *srv, const char *hostname, int dns_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004083{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004084 struct dns_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004085 char *hostname_dn;
4086 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004087
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02004088 /* Note that the server lock is already held. */
4089 if (!srv->resolvers)
4090 return -1;
4091
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004092 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004093 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004094 /* run time DNS resolution was not active for this server
4095 * and we can't enable it at run time for now.
4096 */
4097 if (!srv->dns_requester)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004098 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004099
4100 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004101 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004102 hostname_dn = trash.area;
Christopher Faulet67957bd2017-09-27 11:00:59 +02004103 hostname_dn_len = dns_str_to_dn_label(hostname, hostname_len + 1,
4104 hostname_dn, trash.size);
4105 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004106 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004107
Christopher Faulet67957bd2017-09-27 11:00:59 +02004108 resolution = srv->dns_requester->resolution;
4109 if (resolution &&
4110 resolution->hostname_dn &&
4111 !strcmp(resolution->hostname_dn, hostname_dn))
Christopher Fauletb2812a62017-10-04 16:17:58 +02004112 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004113
Christopher Faulet67957bd2017-09-27 11:00:59 +02004114 dns_unlink_resolution(srv->dns_requester);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004115
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004116 free(srv->hostname);
4117 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02004118 srv->hostname = strdup(hostname);
4119 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004120 srv->hostname_dn_len = hostname_dn_len;
4121 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004122 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004123
Olivier Houchard55dcdf42017-11-06 15:15:04 +01004124 if (dns_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02004125 goto err;
4126
4127 end:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004128 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004129 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02004130 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02004131
4132 err:
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004133 if (!dns_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004134 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02004135 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004136}
4137
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004138/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
4139 * from the state file. This is suited for initial address configuration.
4140 * Returns 0 on success otherwise a non-zero error code. In case of error,
4141 * *err_code, if not NULL, is filled up.
4142 */
4143static int srv_apply_lastaddr(struct server *srv, int *err_code)
4144{
4145 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
4146 if (err_code)
4147 *err_code |= ERR_WARN;
4148 return 1;
4149 }
4150 return 0;
4151}
4152
Willy Tarreau25e51522016-11-04 15:10:17 +01004153/* returns 0 if no error, otherwise a combination of ERR_* flags */
4154static int srv_iterate_initaddr(struct server *srv)
4155{
4156 int return_code = 0;
4157 int err_code;
4158 unsigned int methods;
4159
4160 methods = srv->init_addr_methods;
4161 if (!methods) { // default to "last,libc"
4162 srv_append_initaddr(&methods, SRV_IADDR_LAST);
4163 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
4164 }
4165
Willy Tarreau3eed10e2016-11-07 21:03:16 +01004166 /* "-dr" : always append "none" so that server addresses resolution
4167 * failures are silently ignored, this is convenient to validate some
4168 * configs out of their environment.
4169 */
4170 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
4171 srv_append_initaddr(&methods, SRV_IADDR_NONE);
4172
Willy Tarreau25e51522016-11-04 15:10:17 +01004173 while (methods) {
4174 err_code = 0;
4175 switch (srv_get_next_initaddr(&methods)) {
4176 case SRV_IADDR_LAST:
4177 if (!srv->lastaddr)
4178 continue;
4179 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004180 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004181 return_code |= err_code;
4182 break;
4183
4184 case SRV_IADDR_LIBC:
4185 if (!srv->hostname)
4186 continue;
4187 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01004188 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01004189 return_code |= err_code;
4190 break;
4191
Willy Tarreau37ebe122016-11-04 15:17:58 +01004192 case SRV_IADDR_NONE:
4193 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004194 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004195 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
4196 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
Willy Tarreau465b6e52016-11-07 19:19:22 +01004197 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01004198 return return_code;
4199
Willy Tarreau4310d362016-11-02 15:05:56 +01004200 case SRV_IADDR_IP:
4201 ipcpy(&srv->init_addr, &srv->addr);
4202 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004203 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', falling back to configured address.\n",
4204 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
Willy Tarreau4310d362016-11-02 15:05:56 +01004205 }
Olivier Houchard4e694042017-03-14 20:01:29 +01004206 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01004207
Willy Tarreau25e51522016-11-04 15:10:17 +01004208 default: /* unhandled method */
4209 break;
4210 }
4211 }
4212
4213 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004214 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Willy Tarreau25e51522016-11-04 15:10:17 +01004215 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
4216 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01004217 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004218 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Willy Tarreau465b6e52016-11-07 19:19:22 +01004219 srv->conf.file, srv->conf.line, srv->id, srv->hostname);
4220 }
Willy Tarreau25e51522016-11-04 15:10:17 +01004221
4222 return_code |= ERR_ALERT | ERR_FATAL;
4223 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01004224out:
4225 srv_set_dyncookie(srv);
4226 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01004227}
4228
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004229/*
4230 * This function parses all backends and all servers within each backend
4231 * and performs servers' addr resolution based on information provided by:
4232 * - configuration file
4233 * - server-state file (states provided by an 'old' haproxy process)
4234 *
4235 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
4236 */
4237int srv_init_addr(void)
4238{
4239 struct proxy *curproxy;
4240 int return_code = 0;
4241
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004242 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004243 while (curproxy) {
4244 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004245
4246 /* servers are in backend only */
4247 if (!(curproxy->cap & PR_CAP_BE))
4248 goto srv_init_addr_next;
4249
Willy Tarreau25e51522016-11-04 15:10:17 +01004250 for (srv = curproxy->srv; srv; srv = srv->next)
Willy Tarreau3d609a72017-09-06 14:22:45 +02004251 if (srv->hostname)
4252 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004253
4254 srv_init_addr_next:
4255 curproxy = curproxy->next;
4256 }
4257
4258 return return_code;
4259}
4260
Willy Tarreau46b7f532018-08-21 11:54:26 +02004261/*
4262 * Must be called with the server lock held.
4263 */
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004264const char *update_server_fqdn(struct server *server, const char *fqdn, const char *updater, int dns_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004265{
4266
Willy Tarreau83061a82018-07-13 11:56:34 +02004267 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004268
4269 msg = get_trash_chunk();
4270 chunk_reset(msg);
4271
Olivier Houchard8da5f982017-08-04 18:35:36 +02004272 if (server->hostname && !strcmp(fqdn, server->hostname)) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004273 chunk_appendf(msg, "no need to change the FDQN");
4274 goto out;
4275 }
4276
4277 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
4278 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
4279 goto out;
4280 }
4281
4282 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
4283 server->proxy->id, server->id, server->hostname, fqdn);
4284
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004285 if (srv_set_fqdn(server, fqdn, dns_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004286 chunk_reset(msg);
4287 chunk_appendf(msg, "could not update %s/%s FQDN",
4288 server->proxy->id, server->id);
4289 goto out;
4290 }
4291
4292 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02004293 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004294
4295 out:
4296 if (updater)
4297 chunk_appendf(msg, " by '%s'", updater);
4298 chunk_appendf(msg, "\n");
4299
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004300 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004301}
4302
4303
Willy Tarreau21b069d2016-11-23 17:15:08 +01004304/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
4305 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004306 * 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 +01004307 * used for CLI commands requiring a server name.
4308 * Important: the <arg> is modified to remove the '/'.
4309 */
4310struct server *cli_find_server(struct appctx *appctx, char *arg)
4311{
4312 struct proxy *px;
4313 struct server *sv;
4314 char *line;
4315
4316 /* split "backend/server" and make <line> point to server */
4317 for (line = arg; *line; line++)
4318 if (*line == '/') {
4319 *line++ = '\0';
4320 break;
4321 }
4322
4323 if (!*line || !*arg) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004324 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004325 appctx->ctx.cli.msg = "Require 'backend/server'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004326 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004327 return NULL;
4328 }
4329
4330 if (!get_backend_server(arg, line, &px, &sv)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004331 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004332 appctx->ctx.cli.msg = px ? "No such server.\n" : "No such backend.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004333 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004334 return NULL;
4335 }
4336
4337 if (px->state == PR_STSTOPPED) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004338 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004339 appctx->ctx.cli.msg = "Proxy is disabled.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004340 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau21b069d2016-11-23 17:15:08 +01004341 return NULL;
4342 }
4343
4344 return sv;
4345}
4346
William Lallemand222baf22016-11-19 02:00:33 +01004347
Willy Tarreau46b7f532018-08-21 11:54:26 +02004348/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004349static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01004350{
4351 struct server *sv;
4352 const char *warning;
4353
4354 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4355 return 1;
4356
4357 sv = cli_find_server(appctx, args[2]);
4358 if (!sv)
4359 return 1;
4360
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004361 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02004362
William Lallemand222baf22016-11-19 02:00:33 +01004363 if (strcmp(args[3], "weight") == 0) {
4364 warning = server_parse_weight_change_request(sv, args[4]);
4365 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004366 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004367 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004368 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004369 }
4370 }
4371 else if (strcmp(args[3], "state") == 0) {
4372 if (strcmp(args[4], "ready") == 0)
4373 srv_adm_set_ready(sv);
4374 else if (strcmp(args[4], "drain") == 0)
4375 srv_adm_set_drain(sv);
4376 else if (strcmp(args[4], "maint") == 0)
4377 srv_adm_set_maint(sv);
4378 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004379 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004380 appctx->ctx.cli.msg = "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004381 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004382 }
4383 }
4384 else if (strcmp(args[3], "health") == 0) {
4385 if (sv->track) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004386 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004387 appctx->ctx.cli.msg = "cannot change health on a tracking server.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004388 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004389 }
4390 else if (strcmp(args[4], "up") == 0) {
4391 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004392 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004393 }
4394 else if (strcmp(args[4], "stopping") == 0) {
4395 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004396 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004397 }
4398 else if (strcmp(args[4], "down") == 0) {
4399 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004400 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004401 }
4402 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004403 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004404 appctx->ctx.cli.msg = "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004405 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004406 }
4407 }
4408 else if (strcmp(args[3], "agent") == 0) {
4409 if (!(sv->agent.state & CHK_ST_ENABLED)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004410 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004411 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004412 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004413 }
4414 else if (strcmp(args[4], "up") == 0) {
4415 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02004416 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004417 }
4418 else if (strcmp(args[4], "down") == 0) {
4419 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02004420 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01004421 }
4422 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004423 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004424 appctx->ctx.cli.msg = "'set server <srv> agent' expects 'up' or 'down'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004425 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004426 }
4427 }
Misiek2da082d2017-01-09 09:40:42 +01004428 else if (strcmp(args[3], "agent-addr") == 0) {
4429 if (!(sv->agent.state & CHK_ST_ENABLED)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004430 appctx->ctx.cli.severity = LOG_ERR;
Misiek2da082d2017-01-09 09:40:42 +01004431 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
4432 appctx->st0 = CLI_ST_PRINT;
4433 } else {
4434 if (str2ip(args[4], &sv->agent.addr) == NULL) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004435 appctx->ctx.cli.severity = LOG_ERR;
Misiek2da082d2017-01-09 09:40:42 +01004436 appctx->ctx.cli.msg = "incorrect addr address given for agent.\n";
4437 appctx->st0 = CLI_ST_PRINT;
4438 }
4439 }
4440 }
4441 else if (strcmp(args[3], "agent-send") == 0) {
4442 if (!(sv->agent.state & CHK_ST_ENABLED)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004443 appctx->ctx.cli.severity = LOG_ERR;
Misiek2da082d2017-01-09 09:40:42 +01004444 appctx->ctx.cli.msg = "agent checks are not enabled on this server.\n";
4445 appctx->st0 = CLI_ST_PRINT;
4446 } else {
4447 char *nss = strdup(args[4]);
4448 if (!nss) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004449 appctx->ctx.cli.severity = LOG_ERR;
Misiek2da082d2017-01-09 09:40:42 +01004450 appctx->ctx.cli.msg = "cannot allocate memory for new string.\n";
4451 appctx->st0 = CLI_ST_PRINT;
4452 } else {
4453 free(sv->agent.send_string);
4454 sv->agent.send_string = nss;
4455 sv->agent.send_string_len = strlen(args[4]);
4456 }
4457 }
4458 }
William Lallemand222baf22016-11-19 02:00:33 +01004459 else if (strcmp(args[3], "check-port") == 0) {
4460 int i = 0;
4461 if (strl2irc(args[4], strlen(args[4]), &i) != 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004462 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004463 appctx->ctx.cli.msg = "'set server <srv> check-port' expects an integer as argument.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004464 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004465 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004466 }
4467 if ((i < 0) || (i > 65535)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004468 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004469 appctx->ctx.cli.msg = "provided port is not valid.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004470 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004471 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004472 }
4473 /* prevent the update of port to 0 if MAPPORTS are in use */
4474 if ((sv->flags & SRV_F_MAPPORTS) && (i == 0)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004475 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004476 appctx->ctx.cli.msg = "can't unset 'port' since MAPPORTS is in use.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004477 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004478 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004479 }
4480 sv->check.port = i;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004481 appctx->ctx.cli.severity = LOG_NOTICE;
William Lallemand222baf22016-11-19 02:00:33 +01004482 appctx->ctx.cli.msg = "health check port updated.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004483 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004484 }
4485 else if (strcmp(args[3], "addr") == 0) {
4486 char *addr = NULL;
4487 char *port = NULL;
4488 if (strlen(args[4]) == 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004489 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand222baf22016-11-19 02:00:33 +01004490 appctx->ctx.cli.msg = "set server <b>/<s> addr requires an address and optionally a port.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004491 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004492 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01004493 }
4494 else {
4495 addr = args[4];
4496 }
4497 if (strcmp(args[5], "port") == 0) {
4498 port = args[6];
4499 }
4500 warning = update_server_addr_port(sv, addr, port, "stats socket command");
4501 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004502 appctx->ctx.cli.severity = LOG_WARNING;
William Lallemand222baf22016-11-19 02:00:33 +01004503 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004504 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004505 }
4506 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
4507 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004508 else if (strcmp(args[3], "fqdn") == 0) {
4509 if (!*args[4]) {
Willy Tarreaua0752582017-11-05 10:17:49 +01004510 appctx->ctx.cli.severity = LOG_ERR;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004511 appctx->ctx.cli.msg = "set server <b>/<s> fqdn requires a FQDN.\n";
4512 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004513 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004514 }
Olivier Houchardd16bfe62017-10-31 15:21:19 +01004515 warning = update_server_fqdn(sv, args[4], "stats socket command", 0);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004516 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004517 appctx->ctx.cli.severity = LOG_WARNING;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004518 appctx->ctx.cli.msg = warning;
4519 appctx->st0 = CLI_ST_PRINT;
4520 }
4521 }
William Lallemand222baf22016-11-19 02:00:33 +01004522 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004523 appctx->ctx.cli.severity = LOG_ERR;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02004524 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 +01004525 appctx->st0 = CLI_ST_PRINT;
William Lallemand222baf22016-11-19 02:00:33 +01004526 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01004527 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01004528 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01004529 return 1;
4530}
4531
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004532static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004533{
4534 struct stream_interface *si = appctx->owner;
4535 struct proxy *px;
4536 struct server *sv;
4537 char *line;
4538
4539
4540 /* split "backend/server" and make <line> point to server */
4541 for (line = args[2]; *line; line++)
4542 if (*line == '/') {
4543 *line++ = '\0';
4544 break;
4545 }
4546
4547 if (!*line) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004548 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand6b160942016-11-22 12:34:35 +01004549 appctx->ctx.cli.msg = "Require 'backend/server'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004550 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004551 return 1;
4552 }
4553
4554 if (!get_backend_server(args[2], line, &px, &sv)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004555 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand6b160942016-11-22 12:34:35 +01004556 appctx->ctx.cli.msg = px ? "No such server.\n" : "No such backend.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004557 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004558 return 1;
4559 }
4560
4561 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004562 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
4563 sv->iweight);
4564 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004565 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01004566 return 0;
4567 }
William Lallemand6b160942016-11-22 12:34:35 +01004568 return 1;
4569}
4570
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004571/* Parse a "set weight" command.
4572 *
4573 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004574 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004575static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01004576{
4577 struct server *sv;
4578 const char *warning;
4579
4580 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4581 return 1;
4582
4583 sv = cli_find_server(appctx, args[2]);
4584 if (!sv)
4585 return 1;
4586
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004587 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4588
William Lallemand6b160942016-11-22 12:34:35 +01004589 warning = server_parse_weight_change_request(sv, args[3]);
4590 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004591 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand6b160942016-11-22 12:34:35 +01004592 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004593 appctx->st0 = CLI_ST_PRINT;
William Lallemand6b160942016-11-22 12:34:35 +01004594 }
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004595
4596 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4597
William Lallemand6b160942016-11-22 12:34:35 +01004598 return 1;
4599}
4600
Willy Tarreau46b7f532018-08-21 11:54:26 +02004601/* parse a "set maxconn server" command. It always returns 1.
4602 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004603 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004604 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004605static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01004606{
4607 struct server *sv;
4608 const char *warning;
4609
4610 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4611 return 1;
4612
4613 sv = cli_find_server(appctx, args[3]);
4614 if (!sv)
4615 return 1;
4616
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004617 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
4618
Willy Tarreaub8026272016-11-23 11:26:56 +01004619 warning = server_parse_maxconn_change_request(sv, args[4]);
4620 if (warning) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004621 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreaub8026272016-11-23 11:26:56 +01004622 appctx->ctx.cli.msg = warning;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004623 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaub8026272016-11-23 11:26:56 +01004624 }
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004625
4626 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
4627
Willy Tarreaub8026272016-11-23 11:26:56 +01004628 return 1;
4629}
William Lallemand6b160942016-11-22 12:34:35 +01004630
Willy Tarreau46b7f532018-08-21 11:54:26 +02004631/* parse a "disable agent" command. It always returns 1.
4632 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004633 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004634 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004635static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004636{
4637 struct server *sv;
4638
4639 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4640 return 1;
4641
4642 sv = cli_find_server(appctx, args[2]);
4643 if (!sv)
4644 return 1;
4645
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004646 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004647 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004648 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004649 return 1;
4650}
4651
Willy Tarreau46b7f532018-08-21 11:54:26 +02004652/* parse a "disable health" command. It always returns 1.
4653 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004654 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004655 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004656static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004657{
4658 struct server *sv;
4659
4660 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4661 return 1;
4662
4663 sv = cli_find_server(appctx, args[2]);
4664 if (!sv)
4665 return 1;
4666
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004667 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004668 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004669 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004670 return 1;
4671}
4672
Willy Tarreau46b7f532018-08-21 11:54:26 +02004673/* parse a "disable server" command. It always returns 1.
4674 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004675 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004676 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004677static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004678{
4679 struct server *sv;
4680
4681 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4682 return 1;
4683
4684 sv = cli_find_server(appctx, args[2]);
4685 if (!sv)
4686 return 1;
4687
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004688 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004689 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004690 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004691 return 1;
4692}
4693
Willy Tarreau46b7f532018-08-21 11:54:26 +02004694/* parse a "enable agent" command. It always returns 1.
4695 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004696 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004697 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004698static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004699{
4700 struct server *sv;
4701
4702 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4703 return 1;
4704
4705 sv = cli_find_server(appctx, args[2]);
4706 if (!sv)
4707 return 1;
4708
4709 if (!(sv->agent.state & CHK_ST_CONFIGURED)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02004710 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004711 appctx->ctx.cli.msg = "Agent was not configured on this server, cannot enable.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01004712 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004713 return 1;
4714 }
4715
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004716 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004717 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004718 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004719 return 1;
4720}
4721
Willy Tarreau46b7f532018-08-21 11:54:26 +02004722/* parse a "enable health" command. It always returns 1.
4723 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004724 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004725 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004726static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004727{
4728 struct server *sv;
4729
4730 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4731 return 1;
4732
4733 sv = cli_find_server(appctx, args[2]);
4734 if (!sv)
4735 return 1;
4736
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004737 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004738 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004739 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004740 return 1;
4741}
4742
Willy Tarreau46b7f532018-08-21 11:54:26 +02004743/* parse a "enable server" command. It always returns 1.
4744 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004745 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02004746 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02004747static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01004748{
4749 struct server *sv;
4750
4751 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
4752 return 1;
4753
4754 sv = cli_find_server(appctx, args[2]);
4755 if (!sv)
4756 return 1;
4757
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004758 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004759 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01004760 if (!(sv->flags & SRV_F_COOKIESET)
4761 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
4762 sv->cookie)
4763 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004764 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004765 return 1;
4766}
4767
William Lallemand222baf22016-11-19 02:00:33 +01004768/* register cli keywords */
4769static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004770 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004771 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004772 { { "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 +01004773 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004774 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004775 { { "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 +01004776 { { "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 +01004777 { { "set", "server", NULL }, "set server : change a server's state, weight or address", cli_parse_set_server },
William Lallemand6b160942016-11-22 12:34:35 +01004778 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4779 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4780
William Lallemand222baf22016-11-19 02:00:33 +01004781 {{},}
4782}};
4783
Willy Tarreau0108d902018-11-25 19:14:37 +01004784INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004785
Emeric Brun64cc49c2017-10-03 14:46:45 +02004786/*
4787 * This function applies server's status changes, it is
4788 * is designed to be called asynchronously.
4789 *
Willy Tarreau46b7f532018-08-21 11:54:26 +02004790 * Must be called with the server lock held.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004791 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004792static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004793{
4794 struct check *check = &s->check;
4795 int xferred;
4796 struct proxy *px = s->proxy;
4797 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4798 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4799 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004800 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004801
Emeric Brun64cc49c2017-10-03 14:46:45 +02004802 /* If currently main is not set we try to apply pending state changes */
4803 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4804 int next_admin;
4805
4806 /* Backup next admin */
4807 next_admin = s->next_admin;
4808
4809 /* restore current admin state */
4810 s->next_admin = s->cur_admin;
4811
4812 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4813 s->last_change = now.tv_sec;
4814 if (s->proxy->lbprm.set_server_status_down)
4815 s->proxy->lbprm.set_server_status_down(s);
4816
4817 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4818 srv_shutdown_streams(s, SF_ERR_DOWN);
4819
4820 /* we might have streams queued on this server and waiting for
4821 * a connection. Those which are redispatchable will be queued
4822 * to another server or to the proxy itself.
4823 */
4824 xferred = pendconn_redistribute(s);
4825
4826 tmptrash = alloc_trash_chunk();
4827 if (tmptrash) {
4828 chunk_printf(tmptrash,
4829 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4830 s->proxy->id, s->id);
4831
Emeric Brun5a133512017-10-19 14:42:30 +02004832 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004833 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004834
4835 /* we don't send an alert if the server was previously paused */
4836 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004837 send_log(s->proxy, log_level, "%s.\n",
4838 tmptrash->area);
4839 send_email_alert(s, log_level, "%s",
4840 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004841 free_trash_chunk(tmptrash);
4842 tmptrash = NULL;
4843 }
4844 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4845 set_backend_down(s->proxy);
4846
4847 s->counters.down_trans++;
4848 }
4849 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4850 s->last_change = now.tv_sec;
4851 if (s->proxy->lbprm.set_server_status_down)
4852 s->proxy->lbprm.set_server_status_down(s);
4853
4854 /* we might have streams queued on this server and waiting for
4855 * a connection. Those which are redispatchable will be queued
4856 * to another server or to the proxy itself.
4857 */
4858 xferred = pendconn_redistribute(s);
4859
4860 tmptrash = alloc_trash_chunk();
4861 if (tmptrash) {
4862 chunk_printf(tmptrash,
4863 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4864 s->proxy->id, s->id);
4865
Emeric Brun5a133512017-10-19 14:42:30 +02004866 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004867
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004868 ha_warning("%s.\n", tmptrash->area);
4869 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4870 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004871 free_trash_chunk(tmptrash);
4872 tmptrash = NULL;
4873 }
4874
4875 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4876 set_backend_down(s->proxy);
4877 }
4878 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4879 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4880 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4881 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4882 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4883 s->proxy->last_change = now.tv_sec;
4884 }
4885
4886 if (s->next_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
4887 s->down_time += now.tv_sec - s->last_change;
4888
4889 s->last_change = now.tv_sec;
4890 if (s->next_state == SRV_ST_STARTING)
4891 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4892
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004893 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004894 /* now propagate the status change to any LB algorithms */
4895 if (px->lbprm.update_server_eweight)
4896 px->lbprm.update_server_eweight(s);
4897 else if (srv_willbe_usable(s)) {
4898 if (px->lbprm.set_server_status_up)
4899 px->lbprm.set_server_status_up(s);
4900 }
4901 else {
4902 if (px->lbprm.set_server_status_down)
4903 px->lbprm.set_server_status_down(s);
4904 }
4905
4906 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4907 * and it's not a backup server and its effective weight is > 0,
4908 * then it can accept new connections, so we shut down all streams
4909 * on all backup servers.
4910 */
4911 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4912 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4913 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4914
4915 /* check if we can handle some connections queued at the proxy. We
4916 * will take as many as we can handle.
4917 */
4918 xferred = pendconn_grab_from_px(s);
4919
4920 tmptrash = alloc_trash_chunk();
4921 if (tmptrash) {
4922 chunk_printf(tmptrash,
4923 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4924 s->proxy->id, s->id);
4925
Emeric Brun5a133512017-10-19 14:42:30 +02004926 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004927 ha_warning("%s.\n", tmptrash->area);
4928 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4929 tmptrash->area);
4930 send_email_alert(s, LOG_NOTICE, "%s",
4931 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004932 free_trash_chunk(tmptrash);
4933 tmptrash = NULL;
4934 }
4935
4936 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4937 set_backend_down(s->proxy);
4938 }
4939 else if (s->cur_eweight != s->next_eweight) {
4940 /* now propagate the status change to any LB algorithms */
4941 if (px->lbprm.update_server_eweight)
4942 px->lbprm.update_server_eweight(s);
4943 else if (srv_willbe_usable(s)) {
4944 if (px->lbprm.set_server_status_up)
4945 px->lbprm.set_server_status_up(s);
4946 }
4947 else {
4948 if (px->lbprm.set_server_status_down)
4949 px->lbprm.set_server_status_down(s);
4950 }
4951
4952 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4953 set_backend_down(s->proxy);
4954 }
4955
4956 s->next_admin = next_admin;
4957 }
4958
Emeric Brun5a133512017-10-19 14:42:30 +02004959 /* reset operational state change */
4960 *s->op_st_chg.reason = 0;
4961 s->op_st_chg.status = s->op_st_chg.code = -1;
4962 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004963
4964 /* Now we try to apply pending admin changes */
4965
4966 /* Maintenance must also disable health checks */
4967 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4968 if (s->check.state & CHK_ST_ENABLED) {
4969 s->check.state |= CHK_ST_PAUSED;
4970 check->health = 0;
4971 }
4972
4973 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004974 tmptrash = alloc_trash_chunk();
4975 if (tmptrash) {
4976 chunk_printf(tmptrash,
4977 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4978 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4979 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004980
Olivier Houchard796a2b32017-10-24 17:42:47 +02004981 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004982
Olivier Houchard796a2b32017-10-24 17:42:47 +02004983 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004984 ha_warning("%s.\n", tmptrash->area);
4985 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4986 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004987 }
4988 free_trash_chunk(tmptrash);
4989 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004990 }
Emeric Brun8f298292017-12-06 16:47:17 +01004991 /* commit new admin status */
4992
4993 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004994 }
4995 else { /* server was still running */
4996 check->health = 0; /* failure */
4997 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004998
4999 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02005000 if (s->proxy->lbprm.set_server_status_down)
5001 s->proxy->lbprm.set_server_status_down(s);
5002
Emeric Brun64cc49c2017-10-03 14:46:45 +02005003 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
5004 srv_shutdown_streams(s, SF_ERR_DOWN);
5005
5006 /* we might have streams queued on this server and waiting for
5007 * a connection. Those which are redispatchable will be queued
5008 * to another server or to the proxy itself.
5009 */
5010 xferred = pendconn_redistribute(s);
5011
5012 tmptrash = alloc_trash_chunk();
5013 if (tmptrash) {
5014 chunk_printf(tmptrash,
5015 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
5016 s->flags & SRV_F_BACKUP ? "Backup " : "",
5017 s->proxy->id, s->id,
5018 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5019
5020 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
5021
5022 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005023 ha_warning("%s.\n", tmptrash->area);
5024 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
5025 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005026 }
5027 free_trash_chunk(tmptrash);
5028 tmptrash = NULL;
5029 }
5030 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5031 set_backend_down(s->proxy);
5032
5033 s->counters.down_trans++;
5034 }
5035 }
5036 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
5037 /* OK here we're leaving maintenance, we have many things to check,
5038 * because the server might possibly be coming back up depending on
5039 * its state. In practice, leaving maintenance means that we should
5040 * immediately turn to UP (more or less the slowstart) under the
5041 * following conditions :
5042 * - server is neither checked nor tracked
5043 * - server tracks another server which is not checked
5044 * - server tracks another server which is already up
5045 * Which sums up as something simpler :
5046 * "either the tracking server is up or the server's checks are disabled
5047 * or up". Otherwise we only re-enable health checks. There's a special
5048 * case associated to the stopping state which can be inherited. Note
5049 * that the server might still be in drain mode, which is naturally dealt
5050 * with by the lower level functions.
5051 */
5052
5053 if (s->check.state & CHK_ST_ENABLED) {
5054 s->check.state &= ~CHK_ST_PAUSED;
5055 check->health = check->rise; /* start OK but check immediately */
5056 }
5057
5058 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
5059 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
5060 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
5061 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
5062 s->next_state = SRV_ST_STOPPING;
5063 }
5064 else {
5065 s->next_state = SRV_ST_STARTING;
5066 if (s->slowstart > 0)
5067 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
5068 else
5069 s->next_state = SRV_ST_RUNNING;
5070 }
5071
5072 }
5073
5074 tmptrash = alloc_trash_chunk();
5075 if (tmptrash) {
5076 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5077 chunk_printf(tmptrash,
5078 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
5079 s->flags & SRV_F_BACKUP ? "Backup " : "",
5080 s->proxy->id, s->id,
5081 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5082 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5083 }
5084 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5085 chunk_printf(tmptrash,
5086 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
5087 s->flags & SRV_F_BACKUP ? "Backup " : "",
5088 s->proxy->id, s->id, s->hostname,
5089 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5090 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5091 }
5092 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5093 chunk_printf(tmptrash,
5094 "%sServer %s/%s is %s/%s (leaving maintenance)",
5095 s->flags & SRV_F_BACKUP ? "Backup " : "",
5096 s->proxy->id, s->id,
5097 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
5098 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
5099 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005100 ha_warning("%s.\n", tmptrash->area);
5101 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5102 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005103 free_trash_chunk(tmptrash);
5104 tmptrash = NULL;
5105 }
5106
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005107 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005108 /* now propagate the status change to any LB algorithms */
5109 if (px->lbprm.update_server_eweight)
5110 px->lbprm.update_server_eweight(s);
5111 else if (srv_willbe_usable(s)) {
5112 if (px->lbprm.set_server_status_up)
5113 px->lbprm.set_server_status_up(s);
5114 }
5115 else {
5116 if (px->lbprm.set_server_status_down)
5117 px->lbprm.set_server_status_down(s);
5118 }
5119
5120 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5121 set_backend_down(s->proxy);
5122
Willy Tarreau6a78e612018-08-07 10:14:53 +02005123 /* If the server is set with "on-marked-up shutdown-backup-sessions",
5124 * and it's not a backup server and its effective weight is > 0,
5125 * then it can accept new connections, so we shut down all streams
5126 * on all backup servers.
5127 */
5128 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
5129 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
5130 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
5131
5132 /* check if we can handle some connections queued at the proxy. We
5133 * will take as many as we can handle.
5134 */
5135 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005136 }
5137 else if (s->next_admin & SRV_ADMF_MAINT) {
5138 /* remaining in maintenance mode, let's inform precisely about the
5139 * situation.
5140 */
5141 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
5142 tmptrash = alloc_trash_chunk();
5143 if (tmptrash) {
5144 chunk_printf(tmptrash,
5145 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
5146 s->flags & SRV_F_BACKUP ? "Backup " : "",
5147 s->proxy->id, s->id);
5148
5149 if (s->track) /* normally it's mandatory here */
5150 chunk_appendf(tmptrash, " via %s/%s",
5151 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005152 ha_warning("%s.\n", tmptrash->area);
5153 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5154 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005155 free_trash_chunk(tmptrash);
5156 tmptrash = NULL;
5157 }
5158 }
5159 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
5160 tmptrash = alloc_trash_chunk();
5161 if (tmptrash) {
5162 chunk_printf(tmptrash,
5163 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
5164 s->flags & SRV_F_BACKUP ? "Backup " : "",
5165 s->proxy->id, s->id, s->hostname);
5166
5167 if (s->track) /* normally it's mandatory here */
5168 chunk_appendf(tmptrash, " via %s/%s",
5169 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005170 ha_warning("%s.\n", tmptrash->area);
5171 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5172 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005173 free_trash_chunk(tmptrash);
5174 tmptrash = NULL;
5175 }
5176 }
5177 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
5178 tmptrash = alloc_trash_chunk();
5179 if (tmptrash) {
5180 chunk_printf(tmptrash,
5181 "%sServer %s/%s remains in forced maintenance",
5182 s->flags & SRV_F_BACKUP ? "Backup " : "",
5183 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005184 ha_warning("%s.\n", tmptrash->area);
5185 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5186 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005187 free_trash_chunk(tmptrash);
5188 tmptrash = NULL;
5189 }
5190 }
5191 /* don't report anything when leaving drain mode and remaining in maintenance */
5192
5193 s->cur_admin = s->next_admin;
5194 }
5195
5196 if (!(s->next_admin & SRV_ADMF_MAINT)) {
5197 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
5198 /* drain state is applied only if not yet in maint */
5199
5200 s->last_change = now.tv_sec;
5201 if (px->lbprm.set_server_status_down)
5202 px->lbprm.set_server_status_down(s);
5203
5204 /* we might have streams queued on this server and waiting for
5205 * a connection. Those which are redispatchable will be queued
5206 * to another server or to the proxy itself.
5207 */
5208 xferred = pendconn_redistribute(s);
5209
5210 tmptrash = alloc_trash_chunk();
5211 if (tmptrash) {
5212 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
5213 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
5214 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
5215
5216 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
5217
5218 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005219 ha_warning("%s.\n", tmptrash->area);
5220 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5221 tmptrash->area);
5222 send_email_alert(s, LOG_NOTICE, "%s",
5223 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005224 }
5225 free_trash_chunk(tmptrash);
5226 tmptrash = NULL;
5227 }
5228
5229 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
5230 set_backend_down(s->proxy);
5231 }
5232 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
5233 /* OK completely leaving drain mode */
5234 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
5235 if (s->proxy->last_change < now.tv_sec) // ignore negative times
5236 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
5237 s->proxy->last_change = now.tv_sec;
5238 }
5239
5240 if (s->last_change < now.tv_sec) // ignore negative times
5241 s->down_time += now.tv_sec - s->last_change;
5242 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02005243 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005244
5245 tmptrash = alloc_trash_chunk();
5246 if (tmptrash) {
5247 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5248 chunk_printf(tmptrash,
5249 "%sServer %s/%s is %s (leaving forced drain)",
5250 s->flags & SRV_F_BACKUP ? "Backup " : "",
5251 s->proxy->id, s->id,
5252 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5253 }
5254 else {
5255 chunk_printf(tmptrash,
5256 "%sServer %s/%s is %s (leaving drain)",
5257 s->flags & SRV_F_BACKUP ? "Backup " : "",
5258 s->proxy->id, s->id,
5259 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
5260 if (s->track) /* normally it's mandatory here */
5261 chunk_appendf(tmptrash, " via %s/%s",
5262 s->track->proxy->id, s->track->id);
5263 }
5264
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005265 ha_warning("%s.\n", tmptrash->area);
5266 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5267 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005268 free_trash_chunk(tmptrash);
5269 tmptrash = NULL;
5270 }
5271
5272 /* now propagate the status change to any LB algorithms */
5273 if (px->lbprm.update_server_eweight)
5274 px->lbprm.update_server_eweight(s);
5275 else if (srv_willbe_usable(s)) {
5276 if (px->lbprm.set_server_status_up)
5277 px->lbprm.set_server_status_up(s);
5278 }
5279 else {
5280 if (px->lbprm.set_server_status_down)
5281 px->lbprm.set_server_status_down(s);
5282 }
5283 }
5284 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
5285 /* remaining in drain mode after removing one of its flags */
5286
5287 tmptrash = alloc_trash_chunk();
5288 if (tmptrash) {
5289 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
5290 chunk_printf(tmptrash,
5291 "%sServer %s/%s is leaving forced drain but remains in drain mode",
5292 s->flags & SRV_F_BACKUP ? "Backup " : "",
5293 s->proxy->id, s->id);
5294
5295 if (s->track) /* normally it's mandatory here */
5296 chunk_appendf(tmptrash, " via %s/%s",
5297 s->track->proxy->id, s->track->id);
5298 }
5299 else {
5300 chunk_printf(tmptrash,
5301 "%sServer %s/%s remains in forced drain mode",
5302 s->flags & SRV_F_BACKUP ? "Backup " : "",
5303 s->proxy->id, s->id);
5304 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005305 ha_warning("%s.\n", tmptrash->area);
5306 send_log(s->proxy, LOG_NOTICE, "%s.\n",
5307 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02005308 free_trash_chunk(tmptrash);
5309 tmptrash = NULL;
5310 }
5311
5312 /* commit new admin status */
5313
5314 s->cur_admin = s->next_admin;
5315 }
5316 }
5317
5318 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02005319 *s->adm_st_chg_cause = 0;
5320}
Emeric Brun64cc49c2017-10-03 14:46:45 +02005321
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005322struct task *srv_cleanup_toremove_connections(struct task *task, void *context, unsigned short state)
5323{
5324 struct connection *conn;
5325
5326 while ((conn = LIST_POP_LOCKED(&toremove_connections[tid],
5327 struct connection *, list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02005328 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005329 }
5330
5331 return task;
5332}
5333
Willy Tarreau980855b2019-02-07 14:59:29 +01005334struct task *srv_cleanup_idle_connections(struct task *task, void *context, unsigned short state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005335{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005336 struct server *srv;
5337 struct eb32_node *eb;
5338 int i;
5339 unsigned int next_wakeup;
5340 int need_wakeup = 0;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005341
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005342 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
5343 while (1) {
5344 int srv_is_empty = 1;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005345
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005346 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
5347 if (!eb) {
5348 /* we might have reached the end of the tree, typically because
5349 * <now_ms> is in the first half and we're first scanning the last
5350 * half. Let's loop back to the beginning of the tree now.
5351 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005352
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005353 eb = eb32_first(&idle_conn_srv);
5354 if (likely(!eb))
5355 break;
5356 }
5357 if (tick_is_lt(now_ms, eb->key)) {
5358 /* timer not expired yet, revisit it later */
5359 next_wakeup = eb->key;
5360 need_wakeup = 1;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005361 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005362 }
5363 srv = eb32_entry(eb, struct server, idle_node);
5364 for (i = 0; i < global.nbthread; i++) {
5365 int max_conn = (srv->curr_idle_thr[i] / 2) +
5366 (srv->curr_idle_thr[i] & 1);
5367 int j;
5368 int did_remove = 0;
5369
5370 for (j = 0; j < max_conn; j++) {
5371 struct connection *conn = LIST_POP_LOCKED(&srv->idle_orphan_conns[i], struct connection *, list);
5372 if (!conn)
5373 break;
5374 did_remove = 1;
5375 LIST_ADDQ_LOCKED(&toremove_connections[i], &conn->list);
5376 }
5377 if (did_remove && max_conn < srv->curr_idle_thr[i])
5378 srv_is_empty = 0;
5379 if (did_remove)
5380 task_wakeup(idle_conn_cleanup[i], TASK_WOKEN_OTHER);
5381 }
5382 eb32_delete(&srv->idle_node);
5383 if (!srv_is_empty) {
5384 /* There are still more idle connections, add the
5385 * server back in the tree.
5386 */
5387 srv->idle_node.key = tick_add(srv->pool_purge_delay,
5388 now_ms);
5389 eb32_insert(&idle_conn_srv, &srv->idle_node);
5390 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005391 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005392 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
5393
5394 if (need_wakeup)
5395 task->expire = next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01005396 else
5397 task->expire = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01005398
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01005399 return task;
5400}
Olivier Houchard88698d92019-04-16 19:07:22 +02005401
5402/* config parser for global "tune.pool-{low,high}-fd-ratio" */
5403static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
5404 struct proxy *defpx, const char *file, int line,
5405 char **err)
5406{
5407 int arg = -1;
5408
5409 if (too_many_args(1, args, err, NULL))
5410 return -1;
5411
5412 if (*(args[1]) != 0)
5413 arg = atoi(args[1]);
5414
5415 if (arg < 0 || arg > 100) {
5416 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
5417 return -1;
5418 }
5419
5420 if (args[0][10] == 'h')
5421 global.tune.pool_high_ratio = arg;
5422 else
5423 global.tune.pool_low_ratio = arg;
5424 return 0;
5425}
5426
5427/* config keyword parsers */
5428static struct cfg_kw_list cfg_kws = {ILH, {
5429 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
5430 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
5431 { 0, NULL, NULL }
5432}};
5433
5434INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
5435
Baptiste Assmanna68ca962015-04-14 01:15:08 +02005436/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02005437 * Local variables:
5438 * c-indent-level: 8
5439 * c-basic-offset: 8
5440 * End:
5441 */