blob: f8fbe6a9a11e3bf20cbfe775a4e30367259e2c8f [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>
15
16#include <common/cfgparse.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020017#include <common/config.h>
Willy Tarreaudff55432012-10-10 17:51:05 +020018#include <common/errors.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010019#include <common/namespace.h>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020020#include <common/time.h>
21
Willy Tarreau272adea2014-03-31 10:39:59 +020022#include <types/global.h>
Baptiste Assmanna68ca962015-04-14 01:15:08 +020023#include <types/dns.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020024
Simon Hormanb1900d52015-01-30 11:22:54 +090025#include <proto/checks.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020026#include <proto/port_range.h>
27#include <proto/protocol.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020028#include <proto/queue.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020029#include <proto/raw_sock.h>
Willy Tarreauec6c5df2008-07-15 00:22:45 +020030#include <proto/server.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020031#include <proto/stream.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020032#include <proto/task.h>
Baptiste Assmanna68ca962015-04-14 01:15:08 +020033#include <proto/dns.h>
Willy Tarreau4aac7db2014-05-16 11:48:10 +020034
Willy Tarreaubaaee002006-06-26 02:48:02 +020035
Willy Tarreau21faa912012-10-10 08:27:36 +020036/* List head of all known server keywords */
37static struct srv_kw_list srv_keywords = {
38 .list = LIST_HEAD_INIT(srv_keywords.list)
39};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020040
Simon Hormana3608442013-11-01 16:46:15 +090041int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020042{
Willy Tarreau892337c2014-05-13 23:41:20 +020043 if ((s->state != SRV_ST_STOPPED) && s->last_change < now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020044 return s->down_time;
45
46 return now.tv_sec - s->last_change + s->down_time;
47}
Willy Tarreaubaaee002006-06-26 02:48:02 +020048
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050049int srv_lastsession(const struct server *s)
50{
51 if (s->counters.last_sess)
52 return now.tv_sec - s->counters.last_sess;
53
54 return -1;
55}
56
Simon Horman4a741432013-02-23 15:35:38 +090057int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020058{
Simon Horman4a741432013-02-23 15:35:38 +090059 const struct server *s = check->server;
60
Willy Tarreauff5ae352013-12-11 20:36:34 +010061 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090062 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010063
Willy Tarreau892337c2014-05-13 23:41:20 +020064 if ((s->state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +090065 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010066
Simon Horman4a741432013-02-23 15:35:38 +090067 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010068}
69
Willy Tarreau21faa912012-10-10 08:27:36 +020070/*
71 * Registers the server keyword list <kwl> as a list of valid keywords for next
72 * parsing sessions.
73 */
74void srv_register_keywords(struct srv_kw_list *kwl)
75{
76 LIST_ADDQ(&srv_keywords.list, &kwl->list);
77}
78
79/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
80 * keyword is found with a NULL ->parse() function, then an attempt is made to
81 * find one with a valid ->parse() function. This way it is possible to declare
82 * platform-dependant, known keywords as NULL, then only declare them as valid
83 * if some options are met. Note that if the requested keyword contains an
84 * opening parenthesis, everything from this point is ignored.
85 */
86struct srv_kw *srv_find_kw(const char *kw)
87{
88 int index;
89 const char *kwend;
90 struct srv_kw_list *kwl;
91 struct srv_kw *ret = NULL;
92
93 kwend = strchr(kw, '(');
94 if (!kwend)
95 kwend = kw + strlen(kw);
96
97 list_for_each_entry(kwl, &srv_keywords.list, list) {
98 for (index = 0; kwl->kw[index].kw != NULL; index++) {
99 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
100 kwl->kw[index].kw[kwend-kw] == 0) {
101 if (kwl->kw[index].parse)
102 return &kwl->kw[index]; /* found it !*/
103 else
104 ret = &kwl->kw[index]; /* may be OK */
105 }
106 }
107 }
108 return ret;
109}
110
111/* Dumps all registered "server" keywords to the <out> string pointer. The
112 * unsupported keywords are only dumped if their supported form was not
113 * found.
114 */
115void srv_dump_kws(char **out)
116{
117 struct srv_kw_list *kwl;
118 int index;
119
120 *out = NULL;
121 list_for_each_entry(kwl, &srv_keywords.list, list) {
122 for (index = 0; kwl->kw[index].kw != NULL; index++) {
123 if (kwl->kw[index].parse ||
124 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
125 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
126 kwl->scope,
127 kwl->kw[index].kw,
128 kwl->kw[index].skip ? " <arg>" : "",
129 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
130 kwl->kw[index].parse ? "" : " (not supported)");
131 }
132 }
133 }
134}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100135
Willy Tarreaudff55432012-10-10 17:51:05 +0200136/* parse the "id" server keyword */
137static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
138{
139 struct eb32_node *node;
140
141 if (!*args[*cur_arg + 1]) {
142 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
143 return ERR_ALERT | ERR_FATAL;
144 }
145
146 newsrv->puid = atol(args[*cur_arg + 1]);
147 newsrv->conf.id.key = newsrv->puid;
148
149 if (newsrv->puid <= 0) {
150 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
151 return ERR_ALERT | ERR_FATAL;
152 }
153
154 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
155 if (node) {
156 struct server *target = container_of(node, struct server, conf.id);
157 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
158 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
159 target->id);
160 return ERR_ALERT | ERR_FATAL;
161 }
162
163 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200164 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200165 return 0;
166}
167
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200168/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200169 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200170 * shutdown.
171 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200172void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200173{
Willy Tarreau87b09662015-04-03 00:22:06 +0200174 struct stream *stream, *stream_bck;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200175
Willy Tarreau87b09662015-04-03 00:22:06 +0200176 list_for_each_entry_safe(stream, stream_bck, &srv->actconns, by_srv)
177 if (stream->srv_conn == srv)
178 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200179}
180
181/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200182 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200183 * the reason for the shutdown.
184 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200185void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200186{
187 struct server *srv;
188
189 for (srv = px->srv; srv != NULL; srv = srv->next)
190 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200191 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200192}
193
Willy Tarreaubda92272014-05-20 21:55:30 +0200194/* Appends some information to a message string related to a server going UP or
195 * DOWN. If both <forced> and <reason> are null and the server tracks another
196 * one, a "via" information will be provided to know where the status came from.
197 * If <reason> is non-null, the entire string will be appended after a comma and
198 * a space (eg: to report some information from the check that changed the state).
Willy Tarreau87b09662015-04-03 00:22:06 +0200199 * If <xferred> is non-negative, some information about requeued streams are
Willy Tarreaubda92272014-05-20 21:55:30 +0200200 * provided.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200201 */
Willy Tarreaubda92272014-05-20 21:55:30 +0200202void srv_append_status(struct chunk *msg, struct server *s, const char *reason, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200203{
Willy Tarreaubda92272014-05-20 21:55:30 +0200204 if (reason)
205 chunk_appendf(msg, ", %s", reason);
206 else if (!forced && s->track)
207 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200208
209 if (xferred >= 0) {
210 if (s->state == SRV_ST_STOPPED)
211 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
212 " %d sessions active, %d requeued, %d remaining in queue",
213 s->proxy->srv_act, s->proxy->srv_bck,
214 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
215 s->cur_sess, xferred, s->nbpend);
216 else
217 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
218 " %d sessions requeued, %d total in queue",
219 s->proxy->srv_act, s->proxy->srv_bck,
220 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
221 xferred, s->nbpend);
222 }
223}
224
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200225/* Marks server <s> down, regardless of its checks' statuses, notifies by all
226 * available means, recounts the remaining servers on the proxy and transfers
Willy Tarreau87b09662015-04-03 00:22:06 +0200227 * queued streams whenever possible to other servers. It automatically
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200228 * recomputes the number of servers, but not the map. Maintenance servers are
229 * ignored. It reports <reason> if non-null as the reason for going down. Note
230 * that it makes use of the trash to build the log strings, so <reason> must
231 * not be placed there.
232 */
233void srv_set_stopped(struct server *s, const char *reason)
234{
235 struct server *srv;
236 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
237 int srv_was_stopping = (s->state == SRV_ST_STOPPING);
Simon Horman64e34162015-02-06 11:11:57 +0900238 int log_level;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200239 int xferred;
240
241 if ((s->admin & SRV_ADMF_MAINT) || s->state == SRV_ST_STOPPED)
242 return;
243
244 s->last_change = now.tv_sec;
245 s->state = SRV_ST_STOPPED;
246 if (s->proxy->lbprm.set_server_status_down)
247 s->proxy->lbprm.set_server_status_down(s);
248
249 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
Willy Tarreaue7dff022015-04-03 01:14:29 +0200250 srv_shutdown_streams(s, SF_ERR_DOWN);
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200251
Willy Tarreau87b09662015-04-03 00:22:06 +0200252 /* we might have streams queued on this server and waiting for
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200253 * a connection. Those which are redispatchable will be queued
254 * to another server or to the proxy itself.
255 */
256 xferred = pendconn_redistribute(s);
257
258 chunk_printf(&trash,
259 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
260 s->proxy->id, s->id);
261
262 srv_append_status(&trash, s, reason, xferred, 0);
263 Warning("%s.\n", trash.str);
264
265 /* we don't send an alert if the server was previously paused */
Simon Horman64e34162015-02-06 11:11:57 +0900266 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
267 send_log(s->proxy, log_level, "%s.\n", trash.str);
268 send_email_alert(s, log_level, "%s", trash.str);
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200269
270 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
271 set_backend_down(s->proxy);
272
273 s->counters.down_trans++;
274
275 for (srv = s->trackers; srv; srv = srv->tracknext)
276 srv_set_stopped(srv, NULL);
277}
278
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200279/* Marks server <s> up regardless of its checks' statuses and provided it isn't
280 * in maintenance. Notifies by all available means, recounts the remaining
281 * servers on the proxy and tries to grab requests from the proxy. It
282 * automatically recomputes the number of servers, but not the map. Maintenance
283 * servers are ignored. It reports <reason> if non-null as the reason for going
284 * up. Note that it makes use of the trash to build the log strings, so <reason>
285 * must not be placed there.
286 */
287void srv_set_running(struct server *s, const char *reason)
288{
289 struct server *srv;
290 int xferred;
291
292 if (s->admin & SRV_ADMF_MAINT)
293 return;
294
295 if (s->state == SRV_ST_STARTING || s->state == SRV_ST_RUNNING)
296 return;
297
298 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
299 if (s->proxy->last_change < now.tv_sec) // ignore negative times
300 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
301 s->proxy->last_change = now.tv_sec;
302 }
303
304 if (s->state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
305 s->down_time += now.tv_sec - s->last_change;
306
307 s->last_change = now.tv_sec;
308
309 s->state = SRV_ST_STARTING;
310 if (s->slowstart > 0)
311 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
312 else
313 s->state = SRV_ST_RUNNING;
314
315 server_recalc_eweight(s);
316
317 /* If the server is set with "on-marked-up shutdown-backup-sessions",
318 * and it's not a backup server and its effective weight is > 0,
Willy Tarreau87b09662015-04-03 00:22:06 +0200319 * then it can accept new connections, so we shut down all streams
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200320 * on all backup servers.
321 */
322 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
323 !(s->flags & SRV_F_BACKUP) && s->eweight)
Willy Tarreaue7dff022015-04-03 01:14:29 +0200324 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200325
326 /* check if we can handle some connections queued at the proxy. We
327 * will take as many as we can handle.
328 */
329 xferred = pendconn_grab_from_px(s);
330
331 chunk_printf(&trash,
332 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
333 s->proxy->id, s->id);
334
335 srv_append_status(&trash, s, reason, xferred, 0);
336 Warning("%s.\n", trash.str);
337 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
Simon Horman4cd477f2015-04-30 13:10:34 +0900338 send_email_alert(s, LOG_NOTICE, "%s", trash.str);
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200339
340 for (srv = s->trackers; srv; srv = srv->tracknext)
341 srv_set_running(srv, NULL);
342}
343
Willy Tarreau8eb77842014-05-21 13:54:57 +0200344/* Marks server <s> stopping regardless of its checks' statuses and provided it
345 * isn't in maintenance. Notifies by all available means, recounts the remaining
346 * servers on the proxy and tries to grab requests from the proxy. It
347 * automatically recomputes the number of servers, but not the map. Maintenance
348 * servers are ignored. It reports <reason> if non-null as the reason for going
349 * up. Note that it makes use of the trash to build the log strings, so <reason>
350 * must not be placed there.
351 */
352void srv_set_stopping(struct server *s, const char *reason)
353{
354 struct server *srv;
355 int xferred;
356
357 if (s->admin & SRV_ADMF_MAINT)
358 return;
359
360 if (s->state == SRV_ST_STOPPING)
361 return;
362
363 s->last_change = now.tv_sec;
364 s->state = SRV_ST_STOPPING;
365 if (s->proxy->lbprm.set_server_status_down)
366 s->proxy->lbprm.set_server_status_down(s);
367
Willy Tarreau87b09662015-04-03 00:22:06 +0200368 /* we might have streams queued on this server and waiting for
Willy Tarreau8eb77842014-05-21 13:54:57 +0200369 * a connection. Those which are redispatchable will be queued
370 * to another server or to the proxy itself.
371 */
372 xferred = pendconn_redistribute(s);
373
374 chunk_printf(&trash,
375 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
376 s->proxy->id, s->id);
377
378 srv_append_status(&trash, s, reason, xferred, 0);
379
380 Warning("%s.\n", trash.str);
381 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
382
383 if (!s->proxy->srv_bck && !s->proxy->srv_act)
384 set_backend_down(s->proxy);
385
386 for (srv = s->trackers; srv; srv = srv->tracknext)
387 srv_set_stopping(srv, NULL);
388}
Willy Tarreaudbd5e782014-05-20 22:46:35 +0200389
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200390/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
391 * enforce either maint mode or drain mode. It is not allowed to set more than
392 * one flag at once. The equivalent "inherited" flag is propagated to all
393 * tracking servers. Maintenance mode disables health checks (but not agent
394 * checks). When either the flag is already set or no flag is passed, nothing
395 * is done.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200396 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200397void srv_set_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200398{
399 struct check *check = &s->check;
400 struct server *srv;
401 int xferred;
402
403 if (!mode)
404 return;
405
406 /* stop going down as soon as we meet a server already in the same state */
407 if (s->admin & mode)
408 return;
409
410 s->admin |= mode;
411
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200412 /* stop going down if the equivalent flag was already present (forced or inherited) */
413 if (((mode & SRV_ADMF_MAINT) && (s->admin & ~mode & SRV_ADMF_MAINT)) ||
414 ((mode & SRV_ADMF_DRAIN) && (s->admin & ~mode & SRV_ADMF_DRAIN)))
415 return;
416
417 /* Maintenance must also disable health checks */
418 if (mode & SRV_ADMF_MAINT) {
419 if (s->check.state & CHK_ST_ENABLED) {
420 s->check.state |= CHK_ST_PAUSED;
421 check->health = 0;
422 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200423
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200424 if (s->state == SRV_ST_STOPPED) { /* server was already down */
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200425 chunk_printf(&trash,
426 "%sServer %s/%s was DOWN and now enters maintenance",
427 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id);
428
Willy Tarreaubda92272014-05-20 21:55:30 +0200429 srv_append_status(&trash, s, NULL, -1, (mode & SRV_ADMF_FMAINT));
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200430
431 Warning("%s.\n", trash.str);
432 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
433 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200434 else { /* server was still running */
435 int srv_was_stopping = (s->state == SRV_ST_STOPPING) || (s->admin & SRV_ADMF_DRAIN);
436 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
437
438 check->health = 0; /* failure */
439 s->last_change = now.tv_sec;
440 s->state = SRV_ST_STOPPED;
441 if (s->proxy->lbprm.set_server_status_down)
442 s->proxy->lbprm.set_server_status_down(s);
443
444 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
Willy Tarreaue7dff022015-04-03 01:14:29 +0200445 srv_shutdown_streams(s, SF_ERR_DOWN);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200446
Willy Tarreau87b09662015-04-03 00:22:06 +0200447 /* we might have streams queued on this server and waiting for
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200448 * a connection. Those which are redispatchable will be queued
449 * to another server or to the proxy itself.
450 */
451 xferred = pendconn_redistribute(s);
452
453 chunk_printf(&trash,
454 "%sServer %s/%s is going DOWN for maintenance",
455 s->flags & SRV_F_BACKUP ? "Backup " : "",
456 s->proxy->id, s->id);
457
458 srv_append_status(&trash, s, NULL, xferred, (mode & SRV_ADMF_FMAINT));
459
460 Warning("%s.\n", trash.str);
461 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n", trash.str);
462
463 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
464 set_backend_down(s->proxy);
465
466 s->counters.down_trans++;
467 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200468 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200469
470 /* drain state is applied only if not yet in maint */
471 if ((mode & SRV_ADMF_DRAIN) && !(s->admin & SRV_ADMF_MAINT)) {
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200472 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
473
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200474 s->last_change = now.tv_sec;
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200475 if (s->proxy->lbprm.set_server_status_down)
476 s->proxy->lbprm.set_server_status_down(s);
477
Willy Tarreau87b09662015-04-03 00:22:06 +0200478 /* we might have streams queued on this server and waiting for
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200479 * a connection. Those which are redispatchable will be queued
480 * to another server or to the proxy itself.
481 */
482 xferred = pendconn_redistribute(s);
483
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200484 chunk_printf(&trash, "%sServer %s/%s enters drain state",
485 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200486
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200487 srv_append_status(&trash, s, NULL, xferred, (mode & SRV_ADMF_FDRAIN));
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200488
489 Warning("%s.\n", trash.str);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200490 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
Simon Horman4cd477f2015-04-30 13:10:34 +0900491 send_email_alert(s, LOG_NOTICE, "%s", trash.str);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200492
493 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
494 set_backend_down(s->proxy);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200495 }
496
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200497 /* compute the inherited flag to propagate */
498 if (mode & SRV_ADMF_MAINT)
499 mode = SRV_ADMF_IMAINT;
500 else if (mode & SRV_ADMF_DRAIN)
501 mode = SRV_ADMF_IDRAIN;
502
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200503 for (srv = s->trackers; srv; srv = srv->tracknext)
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200504 srv_set_admin_flag(srv, mode);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200505}
506
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200507/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
508 * stop enforcing either maint mode or drain mode. It is not allowed to set more
509 * than one flag at once. The equivalent "inherited" flag is propagated to all
510 * tracking servers. Leaving maintenance mode re-enables health checks. When
511 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200512 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200513void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200514{
515 struct check *check = &s->check;
516 struct server *srv;
517 int xferred = -1;
518
519 if (!mode)
520 return;
521
522 /* stop going down as soon as we see the flag is not there anymore */
523 if (!(s->admin & mode))
524 return;
525
526 s->admin &= ~mode;
527
528 if (s->admin & SRV_ADMF_MAINT) {
529 /* remaining in maintenance mode, let's inform precisely about the
530 * situation.
531 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200532 if (mode & SRV_ADMF_FMAINT) {
533 chunk_printf(&trash,
534 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
535 s->flags & SRV_F_BACKUP ? "Backup " : "",
536 s->proxy->id, s->id);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200537
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200538 if (s->track) /* normally it's mandatory here */
539 chunk_appendf(&trash, " via %s/%s",
540 s->track->proxy->id, s->track->id);
541 Warning("%s.\n", trash.str);
542 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
543 }
544 else if (mode & SRV_ADMF_IMAINT) {
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200545 chunk_printf(&trash,
546 "%sServer %s/%s remains in forced maintenance",
547 s->flags & SRV_F_BACKUP ? "Backup " : "",
548 s->proxy->id, s->id);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200549 Warning("%s.\n", trash.str);
550 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
551 }
552 /* don't report anything when leaving drain mode and remaining in maintenance */
553 }
554 else if (mode & SRV_ADMF_MAINT) {
555 /* OK here we're leaving maintenance, we have many things to check,
556 * because the server might possibly be coming back up depending on
557 * its state. In practice, leaving maintenance means that we should
558 * immediately turn to UP (more or less the slowstart) under the
559 * following conditions :
560 * - server is neither checked nor tracked
561 * - server tracks another server which is not checked
562 * - server tracks another server which is already up
563 * Which sums up as something simpler :
564 * "either the tracking server is up or the server's checks are disabled
565 * or up". Otherwise we only re-enable health checks. There's a special
566 * case associated to the stopping state which can be inherited. Note
567 * that the server might still be in drain mode, which is naturally dealt
568 * with by the lower level functions.
569 */
570
571 if (s->check.state & CHK_ST_ENABLED) {
572 s->check.state &= ~CHK_ST_PAUSED;
573 check->health = check->rise; /* start OK but check immediately */
574 }
575
576 if ((!s->track || s->track->state != SRV_ST_STOPPED) &&
577 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
578 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
579 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
580 if (s->proxy->last_change < now.tv_sec) // ignore negative times
581 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
582 s->proxy->last_change = now.tv_sec;
583 }
584
585 if (s->last_change < now.tv_sec) // ignore negative times
586 s->down_time += now.tv_sec - s->last_change;
587 s->last_change = now.tv_sec;
588
589 if (s->track && s->track->state == SRV_ST_STOPPING)
590 s->state = SRV_ST_STOPPING;
591 else {
592 s->state = SRV_ST_STARTING;
593 if (s->slowstart > 0)
594 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
595 else
596 s->state = SRV_ST_RUNNING;
597 }
598
599 server_recalc_eweight(s);
600
601 /* If the server is set with "on-marked-up shutdown-backup-sessions",
602 * and it's not a backup server and its effective weight is > 0,
Willy Tarreau87b09662015-04-03 00:22:06 +0200603 * then it can accept new connections, so we shut down all streams
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200604 * on all backup servers.
605 */
606 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
607 !(s->flags & SRV_F_BACKUP) && s->eweight)
Willy Tarreaue7dff022015-04-03 01:14:29 +0200608 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200609
610 /* check if we can handle some connections queued at the proxy. We
611 * will take as many as we can handle.
612 */
613 xferred = pendconn_grab_from_px(s);
614 }
615
616 if (mode & SRV_ADMF_FMAINT) {
617 chunk_printf(&trash,
618 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
619 s->flags & SRV_F_BACKUP ? "Backup " : "",
620 s->proxy->id, s->id,
621 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP",
622 (s->admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200623 }
624 else {
625 chunk_printf(&trash,
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200626 "%sServer %s/%s is %s/%s (leaving maintenance)",
627 s->flags & SRV_F_BACKUP ? "Backup " : "",
628 s->proxy->id, s->id,
629 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP",
630 (s->admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
631 srv_append_status(&trash, s, NULL, xferred, 0);
632 }
633 Warning("%s.\n", trash.str);
634 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
635 }
636 else if ((mode & SRV_ADMF_DRAIN) && (s->admin & SRV_ADMF_DRAIN)) {
637 /* remaining in drain mode after removing one of its flags */
638
639 if (mode & SRV_ADMF_FDRAIN) {
640 chunk_printf(&trash,
641 "%sServer %s/%s is leaving forced drain but remains in drain mode",
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200642 s->flags & SRV_F_BACKUP ? "Backup " : "",
643 s->proxy->id, s->id);
644
645 if (s->track) /* normally it's mandatory here */
646 chunk_appendf(&trash, " via %s/%s",
647 s->track->proxy->id, s->track->id);
648 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200649 else {
650 chunk_printf(&trash,
651 "%sServer %s/%s remains in forced drain mode",
652 s->flags & SRV_F_BACKUP ? "Backup " : "",
653 s->proxy->id, s->id);
654 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200655 Warning("%s.\n", trash.str);
656 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200657 }
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200658 else if (mode & SRV_ADMF_DRAIN) {
659 /* OK completely leaving drain mode */
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200660 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
661 if (s->proxy->last_change < now.tv_sec) // ignore negative times
662 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
663 s->proxy->last_change = now.tv_sec;
664 }
665
666 if (s->last_change < now.tv_sec) // ignore negative times
667 s->down_time += now.tv_sec - s->last_change;
668 s->last_change = now.tv_sec;
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200669 server_recalc_eweight(s);
670
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200671 if (mode & SRV_ADMF_FDRAIN) {
672 chunk_printf(&trash,
673 "%sServer %s/%s is %s (leaving forced drain)",
674 s->flags & SRV_F_BACKUP ? "Backup " : "",
675 s->proxy->id, s->id,
676 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP");
677 }
678 else {
679 chunk_printf(&trash,
680 "%sServer %s/%s is %s (leaving drain)",
681 s->flags & SRV_F_BACKUP ? "Backup " : "",
682 s->proxy->id, s->id,
683 (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP");
684 if (s->track) /* normally it's mandatory here */
685 chunk_appendf(&trash, " via %s/%s",
686 s->track->proxy->id, s->track->id);
687 }
688 Warning("%s.\n", trash.str);
689 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200690 }
691
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200692 /* stop going down if the equivalent flag is still present (forced or inherited) */
693 if (((mode & SRV_ADMF_MAINT) && (s->admin & SRV_ADMF_MAINT)) ||
694 ((mode & SRV_ADMF_DRAIN) && (s->admin & SRV_ADMF_DRAIN)))
695 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200696
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200697 if (mode & SRV_ADMF_MAINT)
698 mode = SRV_ADMF_IMAINT;
699 else if (mode & SRV_ADMF_DRAIN)
700 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200701
702 for (srv = s->trackers; srv; srv = srv->tracknext)
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +0200703 srv_clr_admin_flag(srv, mode);
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200704}
705
Willy Tarreaudff55432012-10-10 17:51:05 +0200706/* Note: must not be declared <const> as its list will be overwritten.
707 * Please take care of keeping this list alphabetically sorted, doing so helps
708 * all code contributors.
709 * Optional keywords are also declared with a NULL ->parse() function so that
710 * the config parser can report an appropriate error when a known keyword was
711 * not enabled.
712 */
713static struct srv_kw_list srv_kws = { "ALL", { }, {
714 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
715 { NULL, NULL, 0 },
716}};
717
718__attribute__((constructor))
719static void __listener_init(void)
720{
721 srv_register_keywords(&srv_kws);
722}
723
Willy Tarreau004e0452013-11-21 11:22:01 +0100724/* Recomputes the server's eweight based on its state, uweight, the current time,
725 * and the proxy's algorihtm. To be used after updating sv->uweight. The warmup
726 * state is automatically disabled if the time is elapsed.
727 */
728void server_recalc_eweight(struct server *sv)
729{
730 struct proxy *px = sv->proxy;
731 unsigned w;
732
733 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
734 /* go to full throttle if the slowstart interval is reached */
Willy Tarreau892337c2014-05-13 23:41:20 +0200735 if (sv->state == SRV_ST_STARTING)
736 sv->state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +0100737 }
738
739 /* We must take care of not pushing the server to full throttle during slow starts.
740 * It must also start immediately, at least at the minimal step when leaving maintenance.
741 */
Willy Tarreau892337c2014-05-13 23:41:20 +0200742 if ((sv->state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +0100743 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
744 else
745 w = px->lbprm.wdiv;
746
747 sv->eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
748
749 /* now propagate the status change to any LB algorithms */
750 if (px->lbprm.update_server_eweight)
751 px->lbprm.update_server_eweight(sv);
Willy Tarreau9943d312014-05-22 16:20:59 +0200752 else if (srv_is_usable(sv)) {
Willy Tarreau004e0452013-11-21 11:22:01 +0100753 if (px->lbprm.set_server_status_up)
754 px->lbprm.set_server_status_up(sv);
755 }
756 else {
757 if (px->lbprm.set_server_status_down)
758 px->lbprm.set_server_status_down(sv);
759 }
760}
761
Willy Tarreaubaaee002006-06-26 02:48:02 +0200762/*
Simon Horman7d09b9a2013-02-12 10:45:51 +0900763 * Parses weight_str and configures sv accordingly.
764 * Returns NULL on success, error message string otherwise.
765 */
766const char *server_parse_weight_change_request(struct server *sv,
767 const char *weight_str)
768{
769 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +0900770 long int w;
771 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +0900772
773 px = sv->proxy;
774
775 /* if the weight is terminated with '%', it is set relative to
776 * the initial weight, otherwise it is absolute.
777 */
778 if (!*weight_str)
779 return "Require <weight> or <weight%>.\n";
780
Simon Hormanb796afa2013-02-12 10:45:53 +0900781 w = strtol(weight_str, &end, 10);
782 if (end == weight_str)
783 return "Empty weight string empty or preceded by garbage";
784 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +0900785 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +0900786 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +0900787 /* Avoid integer overflow */
788 if (w > 25600)
789 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +0900790 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +0900791 if (w > 256)
792 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +0900793 }
794 else if (w < 0 || w > 256)
795 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +0900796 else if (end[0] != '\0')
797 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +0900798
799 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
800 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
801
802 sv->uweight = w;
Willy Tarreau004e0452013-11-21 11:22:01 +0100803 server_recalc_eweight(sv);
Simon Horman7d09b9a2013-02-12 10:45:51 +0900804
805 return NULL;
806}
807
Baptiste Assmann3d8f8312015-04-13 22:54:33 +0200808/*
809 * Parses <addr_str> and configures <sv> accordingly.
810 * Returns:
811 * - error string on error
812 * - NULL on success
813 */
814const char *server_parse_addr_change_request(struct server *sv,
815 const char *addr_str)
816{
817 unsigned char ip[INET6_ADDRSTRLEN];
818
819 if (inet_pton(AF_INET6, addr_str, ip)) {
820 update_server_addr(sv, ip, AF_INET6, "stats command\n");
821 return NULL;
822 }
823 if (inet_pton(AF_INET, addr_str, ip)) {
824 update_server_addr(sv, ip, AF_INET, "stats command\n");
825 return NULL;
826 }
827
828 return "Could not understand IP address format.\n";
829}
830
Willy Tarreau272adea2014-03-31 10:39:59 +0200831int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy, struct proxy *defproxy)
832{
833 struct server *newsrv = NULL;
834 const char *err;
835 char *errmsg = NULL;
836 int err_code = 0;
837 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +0200838 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +0200839
840 if (!strcmp(args[0], "server") || !strcmp(args[0], "default-server")) { /* server address */
841 int cur_arg;
842 short realport = 0;
843 int do_agent = 0, do_check = 0, defsrv = (*args[0] == 'd');
844
845 if (!defsrv && curproxy == defproxy) {
846 Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
847 err_code |= ERR_ALERT | ERR_FATAL;
848 goto out;
849 }
850 else if (warnifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL))
851 err_code |= ERR_ALERT | ERR_FATAL;
852
853 if (!*args[2]) {
854 Alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
855 file, linenum, args[0]);
856 err_code |= ERR_ALERT | ERR_FATAL;
857 goto out;
858 }
859
860 err = invalid_char(args[1]);
861 if (err && !defsrv) {
862 Alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
863 file, linenum, *err, args[1]);
864 err_code |= ERR_ALERT | ERR_FATAL;
865 goto out;
866 }
867
868 if (!defsrv) {
869 struct sockaddr_storage *sk;
870 int port1, port2;
871 struct protocol *proto;
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200872 struct dns_resolution *curr_resolution;
Willy Tarreau272adea2014-03-31 10:39:59 +0200873
874 if ((newsrv = (struct server *)calloc(1, sizeof(struct server))) == NULL) {
875 Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
876 err_code |= ERR_ALERT | ERR_ABORT;
877 goto out;
878 }
879
880 /* the servers are linked backwards first */
881 newsrv->next = curproxy->srv;
882 curproxy->srv = newsrv;
883 newsrv->proxy = curproxy;
884 newsrv->conf.file = strdup(file);
885 newsrv->conf.line = linenum;
886
887 newsrv->obj_type = OBJ_TYPE_SERVER;
888 LIST_INIT(&newsrv->actconns);
889 LIST_INIT(&newsrv->pendconns);
Willy Tarreau600802a2015-08-04 17:19:06 +0200890 LIST_INIT(&newsrv->priv_conns);
Willy Tarreau173a1c62015-08-05 10:31:57 +0200891 LIST_INIT(&newsrv->idle_conns);
Willy Tarreau7017cb02015-08-05 16:35:23 +0200892 LIST_INIT(&newsrv->safe_conns);
Willy Tarreau272adea2014-03-31 10:39:59 +0200893 do_check = 0;
894 do_agent = 0;
Willy Tarreauc93cd162014-05-13 15:54:22 +0200895 newsrv->flags = 0;
Willy Tarreau20125212014-05-13 19:44:56 +0200896 newsrv->admin = 0;
Willy Tarreau892337c2014-05-13 23:41:20 +0200897 newsrv->state = SRV_ST_RUNNING; /* early server setup */
Willy Tarreau272adea2014-03-31 10:39:59 +0200898 newsrv->last_change = now.tv_sec;
899 newsrv->id = strdup(args[1]);
900
901 /* several ways to check the port component :
902 * - IP => port=+0, relative (IPv4 only)
903 * - IP: => port=+0, relative
904 * - IP:N => port=N, absolute
905 * - IP:+N => port=+N, relative
906 * - IP:-N => port=-N, relative
907 */
Willy Tarreau07101d52015-09-08 16:16:35 +0200908 sk = str2sa_range(args[2], &port1, &port2, &errmsg, NULL, &fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +0200909 if (!sk) {
910 Alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
911 err_code |= ERR_ALERT | ERR_FATAL;
912 goto out;
913 }
914
915 proto = protocol_by_family(sk->ss_family);
916 if (!proto || !proto->connect) {
917 Alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
918 file, linenum, args[0], args[1]);
919 err_code |= ERR_ALERT | ERR_FATAL;
920 goto out;
921 }
922
923 if (!port1 || !port2) {
924 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +0200925 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +0200926 }
927 else if (port1 != port2) {
928 /* port range */
929 Alert("parsing [%s:%d] : '%s %s' : port ranges are not allowed in '%s'\n",
930 file, linenum, args[0], args[1], args[2]);
931 err_code |= ERR_ALERT | ERR_FATAL;
932 goto out;
933 }
934 else {
935 /* used by checks */
936 realport = port1;
937 }
938
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200939 /* save hostname and create associated name resolution */
Willy Tarreau07101d52015-09-08 16:16:35 +0200940 newsrv->hostname = fqdn;
941 if (!fqdn)
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200942 goto skip_name_resolution;
943
Willy Tarreau07101d52015-09-08 16:16:35 +0200944 fqdn = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200945 if ((curr_resolution = calloc(1, sizeof(struct dns_resolution))) == NULL)
946 goto skip_name_resolution;
947
948 curr_resolution->hostname_dn_len = dns_str_to_dn_label_len(newsrv->hostname);
949 if ((curr_resolution->hostname_dn = calloc(curr_resolution->hostname_dn_len + 1, sizeof(char))) == NULL)
950 goto skip_name_resolution;
951 if ((dns_str_to_dn_label(newsrv->hostname, curr_resolution->hostname_dn, curr_resolution->hostname_dn_len + 1)) == NULL) {
952 Alert("parsing [%s:%d] : Invalid hostname '%s'\n",
953 file, linenum, args[2]);
954 err_code |= ERR_ALERT | ERR_FATAL;
955 goto out;
956 }
957
958 curr_resolution->requester = newsrv;
959 curr_resolution->requester_cb = snr_resolution_cb;
960 curr_resolution->requester_error_cb = snr_resolution_error_cb;
961 curr_resolution->status = RSLV_STATUS_NONE;
962 curr_resolution->step = RSLV_STEP_NONE;
963 /* a first resolution has been done by the configuration parser */
Baptiste Assmannf046f112015-08-27 22:12:46 +0200964 curr_resolution->last_resolution = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200965 newsrv->resolution = curr_resolution;
966
967 skip_name_resolution:
Willy Tarreau272adea2014-03-31 10:39:59 +0200968 newsrv->addr = *sk;
Cyril Bonté9ce13112014-11-15 22:41:27 +0100969 newsrv->xprt = newsrv->check.xprt = newsrv->agent.xprt = &raw_sock;
Willy Tarreau272adea2014-03-31 10:39:59 +0200970
Thierry FOURNIERbb2ae642015-01-14 11:31:49 +0100971 if (!protocol_by_family(newsrv->addr.ss_family)) {
Willy Tarreau272adea2014-03-31 10:39:59 +0200972 Alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
973 file, linenum, newsrv->addr.ss_family, args[2]);
974 err_code |= ERR_ALERT | ERR_FATAL;
975 goto out;
976 }
977
978 newsrv->check.use_ssl = curproxy->defsrv.check.use_ssl;
979 newsrv->check.port = curproxy->defsrv.check.port;
980 newsrv->check.inter = curproxy->defsrv.check.inter;
981 newsrv->check.fastinter = curproxy->defsrv.check.fastinter;
982 newsrv->check.downinter = curproxy->defsrv.check.downinter;
983 newsrv->agent.use_ssl = curproxy->defsrv.agent.use_ssl;
984 newsrv->agent.port = curproxy->defsrv.agent.port;
985 newsrv->agent.inter = curproxy->defsrv.agent.inter;
986 newsrv->agent.fastinter = curproxy->defsrv.agent.fastinter;
987 newsrv->agent.downinter = curproxy->defsrv.agent.downinter;
988 newsrv->maxqueue = curproxy->defsrv.maxqueue;
989 newsrv->minconn = curproxy->defsrv.minconn;
990 newsrv->maxconn = curproxy->defsrv.maxconn;
991 newsrv->slowstart = curproxy->defsrv.slowstart;
992 newsrv->onerror = curproxy->defsrv.onerror;
993 newsrv->onmarkeddown = curproxy->defsrv.onmarkeddown;
994 newsrv->onmarkedup = curproxy->defsrv.onmarkedup;
995 newsrv->consecutive_errors_limit
996 = curproxy->defsrv.consecutive_errors_limit;
997#ifdef OPENSSL
998 newsrv->use_ssl = curproxy->defsrv.use_ssl;
999#endif
1000 newsrv->uweight = newsrv->iweight
1001 = curproxy->defsrv.iweight;
1002
1003 newsrv->check.status = HCHK_STATUS_INI;
1004 newsrv->check.rise = curproxy->defsrv.check.rise;
1005 newsrv->check.fall = curproxy->defsrv.check.fall;
1006 newsrv->check.health = newsrv->check.rise; /* up, but will fall down at first failure */
1007 newsrv->check.server = newsrv;
Simon Hormane16c1b32015-01-30 11:22:57 +09001008 newsrv->check.tcpcheck_rules = &curproxy->tcpcheck_rules;
Willy Tarreau272adea2014-03-31 10:39:59 +02001009
1010 newsrv->agent.status = HCHK_STATUS_INI;
1011 newsrv->agent.rise = curproxy->defsrv.agent.rise;
1012 newsrv->agent.fall = curproxy->defsrv.agent.fall;
1013 newsrv->agent.health = newsrv->agent.rise; /* up, but will fall down at first failure */
1014 newsrv->agent.server = newsrv;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02001015 newsrv->resolver_family_priority = curproxy->defsrv.resolver_family_priority;
1016 if (newsrv->resolver_family_priority == AF_UNSPEC)
1017 newsrv->resolver_family_priority = AF_INET6;
Willy Tarreau272adea2014-03-31 10:39:59 +02001018
1019 cur_arg = 3;
1020 } else {
1021 newsrv = &curproxy->defsrv;
1022 cur_arg = 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02001023 newsrv->resolver_family_priority = AF_INET6;
Willy Tarreau272adea2014-03-31 10:39:59 +02001024 }
1025
1026 while (*args[cur_arg]) {
1027 if (!strcmp(args[cur_arg], "agent-check")) {
1028 global.maxsock++;
1029 do_agent = 1;
1030 cur_arg += 1;
1031 } else if (!strcmp(args[cur_arg], "agent-inter")) {
1032 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
1033 if (err) {
1034 Alert("parsing [%s:%d] : unexpected character '%c' in 'agent-inter' argument of server %s.\n",
1035 file, linenum, *err, newsrv->id);
1036 err_code |= ERR_ALERT | ERR_FATAL;
1037 goto out;
1038 }
1039 if (val <= 0) {
1040 Alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
1041 file, linenum, val, args[cur_arg], newsrv->id);
1042 err_code |= ERR_ALERT | ERR_FATAL;
1043 goto out;
1044 }
1045 newsrv->agent.inter = val;
1046 cur_arg += 2;
1047 }
1048 else if (!strcmp(args[cur_arg], "agent-port")) {
1049 global.maxsock++;
1050 newsrv->agent.port = atol(args[cur_arg + 1]);
1051 cur_arg += 2;
1052 }
1053 else if (!defsrv && !strcmp(args[cur_arg], "cookie")) {
1054 newsrv->cookie = strdup(args[cur_arg + 1]);
1055 newsrv->cklen = strlen(args[cur_arg + 1]);
1056 cur_arg += 2;
1057 }
1058 else if (!defsrv && !strcmp(args[cur_arg], "redir")) {
1059 newsrv->rdr_pfx = strdup(args[cur_arg + 1]);
1060 newsrv->rdr_len = strlen(args[cur_arg + 1]);
1061 cur_arg += 2;
1062 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02001063 else if (!strcmp(args[cur_arg], "resolvers")) {
1064 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
1065 cur_arg += 2;
1066 }
1067 else if (!strcmp(args[cur_arg], "resolve-prefer")) {
1068 if (!strcmp(args[cur_arg + 1], "ipv4"))
1069 newsrv->resolver_family_priority = AF_INET;
1070 else if (!strcmp(args[cur_arg + 1], "ipv6"))
1071 newsrv->resolver_family_priority = AF_INET6;
1072 else {
1073 Alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
1074 file, linenum, args[cur_arg]);
1075 err_code |= ERR_ALERT | ERR_FATAL;
1076 goto out;
1077 }
1078 cur_arg += 2;
1079 }
Willy Tarreau272adea2014-03-31 10:39:59 +02001080 else if (!strcmp(args[cur_arg], "rise")) {
1081 if (!*args[cur_arg + 1]) {
1082 Alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
1083 file, linenum, args[cur_arg]);
1084 err_code |= ERR_ALERT | ERR_FATAL;
1085 goto out;
1086 }
1087
1088 newsrv->check.rise = atol(args[cur_arg + 1]);
1089 if (newsrv->check.rise <= 0) {
1090 Alert("parsing [%s:%d]: '%s' has to be > 0.\n",
1091 file, linenum, args[cur_arg]);
1092 err_code |= ERR_ALERT | ERR_FATAL;
1093 goto out;
1094 }
1095
1096 if (newsrv->check.health)
1097 newsrv->check.health = newsrv->check.rise;
1098 cur_arg += 2;
1099 }
1100 else if (!strcmp(args[cur_arg], "fall")) {
1101 newsrv->check.fall = atol(args[cur_arg + 1]);
1102
1103 if (!*args[cur_arg + 1]) {
1104 Alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
1105 file, linenum, args[cur_arg]);
1106 err_code |= ERR_ALERT | ERR_FATAL;
1107 goto out;
1108 }
1109
1110 if (newsrv->check.fall <= 0) {
1111 Alert("parsing [%s:%d]: '%s' has to be > 0.\n",
1112 file, linenum, args[cur_arg]);
1113 err_code |= ERR_ALERT | ERR_FATAL;
1114 goto out;
1115 }
1116
1117 cur_arg += 2;
1118 }
1119 else if (!strcmp(args[cur_arg], "inter")) {
1120 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
1121 if (err) {
1122 Alert("parsing [%s:%d] : unexpected character '%c' in 'inter' argument of server %s.\n",
1123 file, linenum, *err, newsrv->id);
1124 err_code |= ERR_ALERT | ERR_FATAL;
1125 goto out;
1126 }
1127 if (val <= 0) {
1128 Alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
1129 file, linenum, val, args[cur_arg], newsrv->id);
1130 err_code |= ERR_ALERT | ERR_FATAL;
1131 goto out;
1132 }
1133 newsrv->check.inter = val;
1134 cur_arg += 2;
1135 }
1136 else if (!strcmp(args[cur_arg], "fastinter")) {
1137 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
1138 if (err) {
1139 Alert("parsing [%s:%d]: unexpected character '%c' in 'fastinter' argument of server %s.\n",
1140 file, linenum, *err, newsrv->id);
1141 err_code |= ERR_ALERT | ERR_FATAL;
1142 goto out;
1143 }
1144 if (val <= 0) {
1145 Alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
1146 file, linenum, val, args[cur_arg], newsrv->id);
1147 err_code |= ERR_ALERT | ERR_FATAL;
1148 goto out;
1149 }
1150 newsrv->check.fastinter = val;
1151 cur_arg += 2;
1152 }
1153 else if (!strcmp(args[cur_arg], "downinter")) {
1154 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
1155 if (err) {
1156 Alert("parsing [%s:%d]: unexpected character '%c' in 'downinter' argument of server %s.\n",
1157 file, linenum, *err, newsrv->id);
1158 err_code |= ERR_ALERT | ERR_FATAL;
1159 goto out;
1160 }
1161 if (val <= 0) {
1162 Alert("parsing [%s:%d]: invalid value %d for argument '%s' of server %s.\n",
1163 file, linenum, val, args[cur_arg], newsrv->id);
1164 err_code |= ERR_ALERT | ERR_FATAL;
1165 goto out;
1166 }
1167 newsrv->check.downinter = val;
1168 cur_arg += 2;
1169 }
1170 else if (!defsrv && !strcmp(args[cur_arg], "addr")) {
1171 struct sockaddr_storage *sk;
1172 int port1, port2;
1173 struct protocol *proto;
1174
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001175 sk = str2sa_range(args[cur_arg + 1], &port1, &port2, &errmsg, NULL, NULL);
Willy Tarreau272adea2014-03-31 10:39:59 +02001176 if (!sk) {
1177 Alert("parsing [%s:%d] : '%s' : %s\n",
1178 file, linenum, args[cur_arg], errmsg);
1179 err_code |= ERR_ALERT | ERR_FATAL;
1180 goto out;
1181 }
1182
1183 proto = protocol_by_family(sk->ss_family);
1184 if (!proto || !proto->connect) {
1185 Alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
1186 file, linenum, args[cur_arg], args[cur_arg + 1]);
1187 err_code |= ERR_ALERT | ERR_FATAL;
1188 goto out;
1189 }
1190
1191 if (port1 != port2) {
1192 Alert("parsing [%s:%d] : '%s' : port ranges and offsets are not allowed in '%s'\n",
1193 file, linenum, args[cur_arg], args[cur_arg + 1]);
1194 err_code |= ERR_ALERT | ERR_FATAL;
1195 goto out;
1196 }
1197
Simon Horman41f58762015-01-30 11:22:56 +09001198 newsrv->check.addr = newsrv->agent.addr = *sk;
Willy Tarreau272adea2014-03-31 10:39:59 +02001199 cur_arg += 2;
1200 }
1201 else if (!strcmp(args[cur_arg], "port")) {
1202 newsrv->check.port = atol(args[cur_arg + 1]);
1203 cur_arg += 2;
1204 }
1205 else if (!defsrv && !strcmp(args[cur_arg], "backup")) {
Willy Tarreauc93cd162014-05-13 15:54:22 +02001206 newsrv->flags |= SRV_F_BACKUP;
Willy Tarreau272adea2014-03-31 10:39:59 +02001207 cur_arg ++;
1208 }
1209 else if (!defsrv && !strcmp(args[cur_arg], "non-stick")) {
Willy Tarreauc93cd162014-05-13 15:54:22 +02001210 newsrv->flags |= SRV_F_NON_STICK;
Willy Tarreau272adea2014-03-31 10:39:59 +02001211 cur_arg ++;
1212 }
1213 else if (!defsrv && !strcmp(args[cur_arg], "send-proxy")) {
David Safb76832014-05-08 23:42:08 -04001214 newsrv->pp_opts |= SRV_PP_V1;
Willy Tarreau272adea2014-03-31 10:39:59 +02001215 cur_arg ++;
1216 }
David Safb76832014-05-08 23:42:08 -04001217 else if (!defsrv && !strcmp(args[cur_arg], "send-proxy-v2")) {
1218 newsrv->pp_opts |= SRV_PP_V2;
1219 cur_arg ++;
1220 }
Willy Tarreau272adea2014-03-31 10:39:59 +02001221 else if (!defsrv && !strcmp(args[cur_arg], "check-send-proxy")) {
1222 newsrv->check.send_proxy = 1;
1223 cur_arg ++;
1224 }
1225 else if (!strcmp(args[cur_arg], "weight")) {
1226 int w;
1227 w = atol(args[cur_arg + 1]);
1228 if (w < 0 || w > SRV_UWGHT_MAX) {
1229 Alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
1230 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
1231 err_code |= ERR_ALERT | ERR_FATAL;
1232 goto out;
1233 }
1234 newsrv->uweight = newsrv->iweight = w;
1235 cur_arg += 2;
1236 }
1237 else if (!strcmp(args[cur_arg], "minconn")) {
1238 newsrv->minconn = atol(args[cur_arg + 1]);
1239 cur_arg += 2;
1240 }
1241 else if (!strcmp(args[cur_arg], "maxconn")) {
1242 newsrv->maxconn = atol(args[cur_arg + 1]);
1243 cur_arg += 2;
1244 }
1245 else if (!strcmp(args[cur_arg], "maxqueue")) {
1246 newsrv->maxqueue = atol(args[cur_arg + 1]);
1247 cur_arg += 2;
1248 }
1249 else if (!strcmp(args[cur_arg], "slowstart")) {
1250 /* slowstart is stored in seconds */
1251 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
1252 if (err) {
1253 Alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
1254 file, linenum, *err, newsrv->id);
1255 err_code |= ERR_ALERT | ERR_FATAL;
1256 goto out;
1257 }
1258 newsrv->slowstart = (val + 999) / 1000;
1259 cur_arg += 2;
1260 }
1261 else if (!defsrv && !strcmp(args[cur_arg], "track")) {
1262
1263 if (!*args[cur_arg + 1]) {
1264 Alert("parsing [%s:%d]: 'track' expects [<proxy>/]<server> as argument.\n",
1265 file, linenum);
1266 err_code |= ERR_ALERT | ERR_FATAL;
1267 goto out;
1268 }
1269
1270 newsrv->trackit = strdup(args[cur_arg + 1]);
1271
1272 cur_arg += 2;
1273 }
1274 else if (!defsrv && !strcmp(args[cur_arg], "check")) {
1275 global.maxsock++;
1276 do_check = 1;
1277 cur_arg += 1;
1278 }
1279 else if (!defsrv && !strcmp(args[cur_arg], "disabled")) {
Baptiste Assmann9f5ada32015-08-08 15:49:13 +02001280 newsrv->admin |= SRV_ADMF_CMAINT;
Willy Tarreau892337c2014-05-13 23:41:20 +02001281 newsrv->state = SRV_ST_STOPPED;
Willy Tarreau272adea2014-03-31 10:39:59 +02001282 newsrv->check.state |= CHK_ST_PAUSED;
1283 newsrv->check.health = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02001284 cur_arg += 1;
1285 }
1286 else if (!defsrv && !strcmp(args[cur_arg], "observe")) {
1287 if (!strcmp(args[cur_arg + 1], "none"))
1288 newsrv->observe = HANA_OBS_NONE;
1289 else if (!strcmp(args[cur_arg + 1], "layer4"))
1290 newsrv->observe = HANA_OBS_LAYER4;
1291 else if (!strcmp(args[cur_arg + 1], "layer7")) {
1292 if (curproxy->mode != PR_MODE_HTTP) {
1293 Alert("parsing [%s:%d]: '%s' can only be used in http proxies.\n",
1294 file, linenum, args[cur_arg + 1]);
1295 err_code |= ERR_ALERT;
1296 }
1297 newsrv->observe = HANA_OBS_LAYER7;
1298 }
1299 else {
1300 Alert("parsing [%s:%d]: '%s' expects one of 'none', "
1301 "'layer4', 'layer7' but got '%s'\n",
1302 file, linenum, args[cur_arg], args[cur_arg + 1]);
1303 err_code |= ERR_ALERT | ERR_FATAL;
1304 goto out;
1305 }
1306
1307 cur_arg += 2;
1308 }
1309 else if (!strcmp(args[cur_arg], "on-error")) {
1310 if (!strcmp(args[cur_arg + 1], "fastinter"))
1311 newsrv->onerror = HANA_ONERR_FASTINTER;
1312 else if (!strcmp(args[cur_arg + 1], "fail-check"))
1313 newsrv->onerror = HANA_ONERR_FAILCHK;
1314 else if (!strcmp(args[cur_arg + 1], "sudden-death"))
1315 newsrv->onerror = HANA_ONERR_SUDDTH;
1316 else if (!strcmp(args[cur_arg + 1], "mark-down"))
1317 newsrv->onerror = HANA_ONERR_MARKDWN;
1318 else {
1319 Alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
1320 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
1321 file, linenum, args[cur_arg], args[cur_arg + 1]);
1322 err_code |= ERR_ALERT | ERR_FATAL;
1323 goto out;
1324 }
1325
1326 cur_arg += 2;
1327 }
1328 else if (!strcmp(args[cur_arg], "on-marked-down")) {
1329 if (!strcmp(args[cur_arg + 1], "shutdown-sessions"))
1330 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
1331 else {
1332 Alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
1333 file, linenum, args[cur_arg], args[cur_arg + 1]);
1334 err_code |= ERR_ALERT | ERR_FATAL;
1335 goto out;
1336 }
1337
1338 cur_arg += 2;
1339 }
1340 else if (!strcmp(args[cur_arg], "on-marked-up")) {
1341 if (!strcmp(args[cur_arg + 1], "shutdown-backup-sessions"))
1342 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
1343 else {
1344 Alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
1345 file, linenum, args[cur_arg], args[cur_arg + 1]);
1346 err_code |= ERR_ALERT | ERR_FATAL;
1347 goto out;
1348 }
1349
1350 cur_arg += 2;
1351 }
1352 else if (!strcmp(args[cur_arg], "error-limit")) {
1353 if (!*args[cur_arg + 1]) {
1354 Alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
1355 file, linenum, args[cur_arg]);
1356 err_code |= ERR_ALERT | ERR_FATAL;
1357 goto out;
1358 }
1359
1360 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
1361
1362 if (newsrv->consecutive_errors_limit <= 0) {
1363 Alert("parsing [%s:%d]: %s has to be > 0.\n",
1364 file, linenum, args[cur_arg]);
1365 err_code |= ERR_ALERT | ERR_FATAL;
1366 goto out;
1367 }
1368 cur_arg += 2;
1369 }
1370 else if (!defsrv && !strcmp(args[cur_arg], "source")) { /* address to which we bind when connecting */
1371 int port_low, port_high;
1372 struct sockaddr_storage *sk;
1373 struct protocol *proto;
1374
1375 if (!*args[cur_arg + 1]) {
1376 Alert("parsing [%s:%d] : '%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, and '%s' <name> as argument.\n",
1377 file, linenum, "source", "usesrc", "interface");
1378 err_code |= ERR_ALERT | ERR_FATAL;
1379 goto out;
1380 }
1381
1382 newsrv->conn_src.opts |= CO_SRC_BIND;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001383 sk = str2sa_range(args[cur_arg + 1], &port_low, &port_high, &errmsg, NULL, NULL);
Willy Tarreau272adea2014-03-31 10:39:59 +02001384 if (!sk) {
1385 Alert("parsing [%s:%d] : '%s %s' : %s\n",
1386 file, linenum, args[cur_arg], args[cur_arg+1], errmsg);
1387 err_code |= ERR_ALERT | ERR_FATAL;
1388 goto out;
1389 }
1390
1391 proto = protocol_by_family(sk->ss_family);
1392 if (!proto || !proto->connect) {
1393 Alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
1394 file, linenum, args[cur_arg], args[cur_arg+1]);
1395 err_code |= ERR_ALERT | ERR_FATAL;
1396 goto out;
1397 }
1398
1399 newsrv->conn_src.source_addr = *sk;
1400
1401 if (port_low != port_high) {
1402 int i;
1403
1404 if (!port_low || !port_high) {
1405 Alert("parsing [%s:%d] : %s does not support port offsets (found '%s').\n",
1406 file, linenum, args[cur_arg], args[cur_arg + 1]);
1407 err_code |= ERR_ALERT | ERR_FATAL;
1408 goto out;
1409 }
1410
1411 if (port_low <= 0 || port_low > 65535 ||
1412 port_high <= 0 || port_high > 65535 ||
1413 port_low > port_high) {
1414 Alert("parsing [%s:%d] : invalid source port range %d-%d.\n",
1415 file, linenum, port_low, port_high);
1416 err_code |= ERR_ALERT | ERR_FATAL;
1417 goto out;
1418 }
1419 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
1420 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
1421 newsrv->conn_src.sport_range->ports[i] = port_low + i;
1422 }
1423
1424 cur_arg += 2;
1425 while (*(args[cur_arg])) {
1426 if (!strcmp(args[cur_arg], "usesrc")) { /* address to use outside */
Willy Tarreau29fbe512015-08-20 19:35:14 +02001427#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreau272adea2014-03-31 10:39:59 +02001428 if (!*args[cur_arg + 1]) {
1429 Alert("parsing [%s:%d] : '%s' expects <addr>[:<port>], 'client', 'clientip', or 'hdr_ip(name,#)' as argument.\n",
1430 file, linenum, "usesrc");
1431 err_code |= ERR_ALERT | ERR_FATAL;
1432 goto out;
1433 }
1434 if (!strcmp(args[cur_arg + 1], "client")) {
1435 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1436 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
1437 } else if (!strcmp(args[cur_arg + 1], "clientip")) {
1438 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1439 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
1440 } else if (!strncmp(args[cur_arg + 1], "hdr_ip(", 7)) {
1441 char *name, *end;
1442
1443 name = args[cur_arg+1] + 7;
1444 while (isspace(*name))
1445 name++;
1446
1447 end = name;
1448 while (*end && !isspace(*end) && *end != ',' && *end != ')')
1449 end++;
1450
1451 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
1452 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
1453 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
1454 newsrv->conn_src.bind_hdr_len = end - name;
1455 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
1456 newsrv->conn_src.bind_hdr_name[end-name] = '\0';
1457 newsrv->conn_src.bind_hdr_occ = -1;
1458
1459 /* now look for an occurrence number */
1460 while (isspace(*end))
1461 end++;
1462 if (*end == ',') {
1463 end++;
1464 name = end;
1465 if (*end == '-')
1466 end++;
1467 while (isdigit((int)*end))
1468 end++;
1469 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end-name);
1470 }
1471
1472 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
1473 Alert("parsing [%s:%d] : usesrc hdr_ip(name,num) does not support negative"
1474 " occurrences values smaller than %d.\n",
1475 file, linenum, MAX_HDR_HISTORY);
1476 err_code |= ERR_ALERT | ERR_FATAL;
1477 goto out;
1478 }
1479 } else {
1480 struct sockaddr_storage *sk;
1481 int port1, port2;
1482
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001483 sk = str2sa_range(args[cur_arg + 1], &port1, &port2, &errmsg, NULL, NULL);
Willy Tarreau272adea2014-03-31 10:39:59 +02001484 if (!sk) {
1485 Alert("parsing [%s:%d] : '%s %s' : %s\n",
1486 file, linenum, args[cur_arg], args[cur_arg+1], errmsg);
1487 err_code |= ERR_ALERT | ERR_FATAL;
1488 goto out;
1489 }
1490
1491 proto = protocol_by_family(sk->ss_family);
1492 if (!proto || !proto->connect) {
1493 Alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
1494 file, linenum, args[cur_arg], args[cur_arg+1]);
1495 err_code |= ERR_ALERT | ERR_FATAL;
1496 goto out;
1497 }
1498
1499 if (port1 != port2) {
1500 Alert("parsing [%s:%d] : '%s' : port ranges and offsets are not allowed in '%s'\n",
1501 file, linenum, args[cur_arg], args[cur_arg + 1]);
1502 err_code |= ERR_ALERT | ERR_FATAL;
1503 goto out;
1504 }
1505 newsrv->conn_src.tproxy_addr = *sk;
1506 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
1507 }
1508 global.last_checks |= LSTCHK_NETADM;
Willy Tarreau272adea2014-03-31 10:39:59 +02001509 cur_arg += 2;
1510 continue;
1511#else /* no TPROXY support */
1512 Alert("parsing [%s:%d] : '%s' not allowed here because support for TPROXY was not compiled in.\n",
1513 file, linenum, "usesrc");
1514 err_code |= ERR_ALERT | ERR_FATAL;
1515 goto out;
Willy Tarreau29fbe512015-08-20 19:35:14 +02001516#endif /* defined(CONFIG_HAP_TRANSPARENT) */
Willy Tarreau272adea2014-03-31 10:39:59 +02001517 } /* "usesrc" */
1518
1519 if (!strcmp(args[cur_arg], "interface")) { /* specifically bind to this interface */
1520#ifdef SO_BINDTODEVICE
1521 if (!*args[cur_arg + 1]) {
1522 Alert("parsing [%s:%d] : '%s' : missing interface name.\n",
1523 file, linenum, args[0]);
1524 err_code |= ERR_ALERT | ERR_FATAL;
1525 goto out;
1526 }
1527 free(newsrv->conn_src.iface_name);
1528 newsrv->conn_src.iface_name = strdup(args[cur_arg + 1]);
1529 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
1530 global.last_checks |= LSTCHK_NETADM;
1531#else
1532 Alert("parsing [%s:%d] : '%s' : '%s' option not implemented.\n",
1533 file, linenum, args[0], args[cur_arg]);
1534 err_code |= ERR_ALERT | ERR_FATAL;
1535 goto out;
1536#endif
1537 cur_arg += 2;
1538 continue;
1539 }
1540 /* this keyword in not an option of "source" */
1541 break;
1542 } /* while */
1543 }
1544 else if (!defsrv && !strcmp(args[cur_arg], "usesrc")) { /* address to use outside: needs "source" first */
1545 Alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
1546 file, linenum, "usesrc", "source");
1547 err_code |= ERR_ALERT | ERR_FATAL;
1548 goto out;
1549 }
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001550 else if (!defsrv && !strcmp(args[cur_arg], "namespace")) {
1551#ifdef CONFIG_HAP_NS
1552 char *arg = args[cur_arg + 1];
1553 if (!strcmp(arg, "*")) {
1554 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
1555 } else {
1556 newsrv->netns = netns_store_lookup(arg, strlen(arg));
1557
1558 if (newsrv->netns == NULL)
1559 newsrv->netns = netns_store_insert(arg);
1560
1561 if (newsrv->netns == NULL) {
1562 Alert("Cannot open namespace '%s'.\n", args[cur_arg + 1]);
1563 err_code |= ERR_ALERT | ERR_FATAL;
1564 goto out;
1565 }
1566 }
1567#else
1568 Alert("parsing [%s:%d] : '%s' : '%s' option not implemented.\n",
1569 file, linenum, args[0], args[cur_arg]);
1570 err_code |= ERR_ALERT | ERR_FATAL;
1571 goto out;
1572#endif
1573 cur_arg += 2;
1574 }
Willy Tarreau272adea2014-03-31 10:39:59 +02001575 else {
1576 static int srv_dumped;
1577 struct srv_kw *kw;
1578 char *err;
1579
1580 kw = srv_find_kw(args[cur_arg]);
1581 if (kw) {
1582 char *err = NULL;
1583 int code;
1584
1585 if (!kw->parse) {
1586 Alert("parsing [%s:%d] : '%s %s' : '%s' option is not implemented in this version (check build options).\n",
1587 file, linenum, args[0], args[1], args[cur_arg]);
1588 cur_arg += 1 + kw->skip ;
1589 err_code |= ERR_ALERT | ERR_FATAL;
1590 goto out;
1591 }
1592
1593 if (defsrv && !kw->default_ok) {
1594 Alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
1595 file, linenum, args[0], args[1], args[cur_arg]);
1596 cur_arg += 1 + kw->skip ;
1597 err_code |= ERR_ALERT;
1598 continue;
1599 }
1600
1601 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
1602 err_code |= code;
1603
1604 if (code) {
1605 if (err && *err) {
1606 indent_msg(&err, 2);
1607 Alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], err);
1608 }
1609 else
1610 Alert("parsing [%s:%d] : '%s %s' : error encountered while processing '%s'.\n",
1611 file, linenum, args[0], args[1], args[cur_arg]);
1612 if (code & ERR_FATAL) {
1613 free(err);
1614 cur_arg += 1 + kw->skip;
1615 goto out;
1616 }
1617 }
1618 free(err);
1619 cur_arg += 1 + kw->skip;
1620 continue;
1621 }
1622
1623 err = NULL;
1624 if (!srv_dumped) {
1625 srv_dump_kws(&err);
1626 indent_msg(&err, 4);
1627 srv_dumped = 1;
1628 }
1629
1630 Alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
1631 file, linenum, args[0], args[1], args[cur_arg],
1632 err ? " Registered keywords :" : "", err ? err : "");
1633 free(err);
1634
1635 err_code |= ERR_ALERT | ERR_FATAL;
1636 goto out;
1637 }
1638 }
1639
Willy Tarreau272adea2014-03-31 10:39:59 +02001640 if (do_check) {
Simon Hormanb1900d52015-01-30 11:22:54 +09001641 const char *ret;
Willy Tarreau272adea2014-03-31 10:39:59 +02001642
1643 if (newsrv->trackit) {
1644 Alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1645 file, linenum);
1646 err_code |= ERR_ALERT | ERR_FATAL;
1647 goto out;
1648 }
1649
1650 /* If neither a port nor an addr was specified and no check transport
1651 * layer is forced, then the transport layer used by the checks is the
1652 * same as for the production traffic. Otherwise we use raw_sock by
1653 * default, unless one is specified.
1654 */
Simon Horman41f58762015-01-30 11:22:56 +09001655 if (!newsrv->check.port && !is_addr(&newsrv->check.addr)) {
Willy Tarreau272adea2014-03-31 10:39:59 +02001656#ifdef USE_OPENSSL
1657 newsrv->check.use_ssl |= (newsrv->use_ssl || (newsrv->proxy->options & PR_O_TCPCHK_SSL));
1658#endif
David Safb76832014-05-08 23:42:08 -04001659 newsrv->check.send_proxy |= (newsrv->pp_opts);
Willy Tarreau272adea2014-03-31 10:39:59 +02001660 }
1661 /* try to get the port from check_core.addr if check.port not set */
1662 if (!newsrv->check.port)
Simon Horman41f58762015-01-30 11:22:56 +09001663 newsrv->check.port = get_host_port(&newsrv->check.addr);
Willy Tarreau272adea2014-03-31 10:39:59 +02001664
1665 if (!newsrv->check.port)
1666 newsrv->check.port = realport; /* by default */
1667
1668 if (!newsrv->check.port) {
1669 /* not yet valid, because no port was set on
1670 * the server either. We'll check if we have
1671 * a known port on the first listener.
1672 */
1673 struct listener *l;
1674
1675 list_for_each_entry(l, &curproxy->conf.listeners, by_fe) {
1676 newsrv->check.port = get_host_port(&l->addr);
1677 if (newsrv->check.port)
1678 break;
1679 }
1680 }
1681 /*
1682 * We need at least a service port, a check port or the first tcp-check rule must
Willy Tarreau5cf0b522014-05-09 23:59:19 +02001683 * be a 'connect' one when checking an IPv4/IPv6 server.
Willy Tarreau272adea2014-03-31 10:39:59 +02001684 */
Willy Tarreau5cf0b522014-05-09 23:59:19 +02001685 if (!newsrv->check.port &&
Simon Horman41f58762015-01-30 11:22:56 +09001686 (is_inet_addr(&newsrv->check.addr) ||
1687 (!is_addr(&newsrv->check.addr) && is_inet_addr(&newsrv->addr)))) {
Willy Tarreau272adea2014-03-31 10:39:59 +02001688 struct tcpcheck_rule *n = NULL, *r = NULL;
1689 struct list *l;
1690
1691 r = (struct tcpcheck_rule *)newsrv->proxy->tcpcheck_rules.n;
1692 if (!r) {
1693 Alert("parsing [%s:%d] : server %s has neither service port nor check port. Check has been disabled.\n",
1694 file, linenum, newsrv->id);
1695 err_code |= ERR_ALERT | ERR_FATAL;
1696 goto out;
1697 }
1698 if ((r->action != TCPCHK_ACT_CONNECT) || !r->port) {
1699 Alert("parsing [%s:%d] : server %s has neither service port nor check port nor tcp_check rule 'connect' with port information. Check has been disabled.\n",
1700 file, linenum, newsrv->id);
1701 err_code |= ERR_ALERT | ERR_FATAL;
1702 goto out;
1703 }
1704 else {
1705 /* scan the tcp-check ruleset to ensure a port has been configured */
1706 l = &newsrv->proxy->tcpcheck_rules;
1707 list_for_each_entry(n, l, list) {
1708 r = (struct tcpcheck_rule *)n->list.p;
1709 if ((r->action == TCPCHK_ACT_CONNECT) && (!r->port)) {
1710 Alert("parsing [%s:%d] : server %s has neither service port nor check port, and a tcp_check rule 'connect' with no port information. Check has been disabled.\n",
1711 file, linenum, newsrv->id);
1712 err_code |= ERR_ALERT | ERR_FATAL;
1713 goto out;
1714 }
1715 }
1716 }
1717 }
1718
1719 /* note: check type will be set during the config review phase */
Simon Hormanb1900d52015-01-30 11:22:54 +09001720 ret = init_check(&newsrv->check, 0);
Willy Tarreau272adea2014-03-31 10:39:59 +02001721 if (ret) {
Simon Hormanb1900d52015-01-30 11:22:54 +09001722 Alert("parsing [%s:%d] : %s.\n", file, linenum, ret);
1723 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau272adea2014-03-31 10:39:59 +02001724 goto out;
1725 }
1726
Baptiste Assmanna68ca962015-04-14 01:15:08 +02001727 if (newsrv->resolution)
1728 newsrv->resolution->resolver_family_priority = newsrv->resolver_family_priority;
1729
Willy Tarreau272adea2014-03-31 10:39:59 +02001730 newsrv->check.state |= CHK_ST_CONFIGURED | CHK_ST_ENABLED;
1731 }
1732
1733 if (do_agent) {
Simon Hormanb1900d52015-01-30 11:22:54 +09001734 const char *ret;
Willy Tarreau272adea2014-03-31 10:39:59 +02001735
1736 if (!newsrv->agent.port) {
1737 Alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
1738 file, linenum, newsrv->id);
1739 err_code |= ERR_ALERT | ERR_FATAL;
1740 goto out;
1741 }
1742
1743 if (!newsrv->agent.inter)
1744 newsrv->agent.inter = newsrv->check.inter;
1745
Simon Hormanb1900d52015-01-30 11:22:54 +09001746 ret = init_check(&newsrv->agent, PR_O2_LB_AGENT_CHK);
Willy Tarreau272adea2014-03-31 10:39:59 +02001747 if (ret) {
Simon Hormanb1900d52015-01-30 11:22:54 +09001748 Alert("parsing [%s:%d] : %s.\n", file, linenum, ret);
1749 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau272adea2014-03-31 10:39:59 +02001750 goto out;
1751 }
1752
1753 newsrv->agent.state |= CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT;
1754 }
1755
1756 if (!defsrv) {
Willy Tarreauc93cd162014-05-13 15:54:22 +02001757 if (newsrv->flags & SRV_F_BACKUP)
Willy Tarreau272adea2014-03-31 10:39:59 +02001758 curproxy->srv_bck++;
1759 else
1760 curproxy->srv_act++;
1761
Willy Tarreauc5150da2014-05-13 19:27:31 +02001762 srv_lb_commit_status(newsrv);
Willy Tarreau272adea2014-03-31 10:39:59 +02001763 }
1764 }
Willy Tarreau07101d52015-09-08 16:16:35 +02001765 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02001766 return 0;
1767
1768 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02001769 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02001770 free(errmsg);
1771 return err_code;
1772}
1773
Baptiste Assmann19a106d2015-07-08 22:03:56 +02001774/* Returns a pointer to the first server matching either id <id>.
1775 * NULL is returned if no match is found.
1776 * the lookup is performed in the backend <bk>
1777 */
1778struct server *server_find_by_id(struct proxy *bk, int id)
1779{
1780 struct eb32_node *eb32;
1781 struct server *curserver;
1782
1783 if (!bk || (id ==0))
1784 return NULL;
1785
1786 /* <bk> has no backend capabilities, so it can't have a server */
1787 if (!(bk->cap & PR_CAP_BE))
1788 return NULL;
1789
1790 curserver = NULL;
1791
1792 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
1793 if (eb32)
1794 curserver = container_of(eb32, struct server, conf.id);
1795
1796 return curserver;
1797}
1798
1799/* Returns a pointer to the first server matching either name <name>, or id
1800 * if <name> starts with a '#'. NULL is returned if no match is found.
1801 * the lookup is performed in the backend <bk>
1802 */
1803struct server *server_find_by_name(struct proxy *bk, const char *name)
1804{
1805 struct server *curserver;
1806
1807 if (!bk || !name)
1808 return NULL;
1809
1810 /* <bk> has no backend capabilities, so it can't have a server */
1811 if (!(bk->cap & PR_CAP_BE))
1812 return NULL;
1813
1814 curserver = NULL;
1815 if (*name == '#') {
1816 curserver = server_find_by_id(bk, atoi(name + 1));
1817 if (curserver)
1818 return curserver;
1819 }
1820 else {
1821 curserver = bk->srv;
1822
1823 while (curserver && (strcmp(curserver->id, name) != 0))
1824 curserver = curserver->next;
1825
1826 if (curserver)
1827 return curserver;
1828 }
1829
1830 return NULL;
1831}
1832
1833struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
1834{
1835 struct server *byname;
1836 struct server *byid;
1837
1838 if (!name && !id)
1839 return NULL;
1840
1841 if (diff)
1842 *diff = 0;
1843
1844 byname = byid = NULL;
1845
1846 if (name) {
1847 byname = server_find_by_name(bk, name);
1848 if (byname && (!id || byname->puid == id))
1849 return byname;
1850 }
1851
1852 /* remaining possibilities :
1853 * - name not set
1854 * - name set but not found
1855 * - name found but ID doesn't match
1856 */
1857 if (id) {
1858 byid = server_find_by_id(bk, id);
1859 if (byid) {
1860 if (byname) {
1861 /* use id only if forced by configuration */
1862 if (byid->flags & SRV_F_FORCED_ID) {
1863 if (diff)
1864 *diff |= 2;
1865 return byid;
1866 }
1867 else {
1868 if (diff)
1869 *diff |= 1;
1870 return byname;
1871 }
1872 }
1873
1874 /* remaining possibilities:
1875 * - name not set
1876 * - name set but not found
1877 */
1878 if (name && diff)
1879 *diff |= 2;
1880 return byid;
1881 }
1882
1883 /* id bot found */
1884 if (byname) {
1885 if (diff)
1886 *diff |= 1;
1887 return byname;
1888 }
1889 }
1890
1891 return NULL;
1892}
1893
Simon Horman7d09b9a2013-02-12 10:45:51 +09001894/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02001895 * update a server's current IP address.
1896 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
1897 * ip is in network format.
1898 * updater is a string which contains an information about the requester of the update.
1899 * updater is used if not NULL.
1900 *
1901 * A log line and a stderr warning message is generated based on server's backend options.
1902 */
1903int update_server_addr(struct server *s, void *ip, int ip_sin_family, char *updater)
1904{
1905 /* generates a log line and a warning on stderr */
1906 if (1) {
1907 /* book enough space for both IPv4 and IPv6 */
1908 char oldip[INET6_ADDRSTRLEN];
1909 char newip[INET6_ADDRSTRLEN];
1910
1911 memset(oldip, '\0', INET6_ADDRSTRLEN);
1912 memset(newip, '\0', INET6_ADDRSTRLEN);
1913
1914 /* copy old IP address in a string */
1915 switch (s->addr.ss_family) {
1916 case AF_INET:
1917 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
1918 break;
1919 case AF_INET6:
1920 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
1921 break;
1922 };
1923
1924 /* copy new IP address in a string */
1925 switch (ip_sin_family) {
1926 case AF_INET:
1927 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
1928 break;
1929 case AF_INET6:
1930 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
1931 break;
1932 };
1933
1934 /* save log line into a buffer */
1935 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
1936 s->proxy->id, s->id, oldip, newip, updater);
1937
1938 /* write the buffer on stderr */
1939 Warning("%s.\n", trash.str);
1940
1941 /* send a log */
1942 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str);
1943 }
1944
1945 /* save the new IP family */
1946 s->addr.ss_family = ip_sin_family;
1947 /* save the new IP address */
1948 switch (ip_sin_family) {
1949 case AF_INET:
1950 ((struct sockaddr_in *)&s->addr)->sin_addr.s_addr = *(uint32_t *)ip;
1951 break;
1952 case AF_INET6:
1953 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
1954 break;
1955 };
1956
1957 return 0;
1958}
1959
1960/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02001961 * update server status based on result of name resolution
1962 * returns:
1963 * 0 if server status is updated
1964 * 1 if server status has not changed
1965 */
1966int snr_update_srv_status(struct server *s)
1967{
1968 struct dns_resolution *resolution = s->resolution;
1969
1970 switch (resolution->status) {
1971 case RSLV_STATUS_NONE:
1972 /* status when HAProxy has just (re)started */
1973 trigger_resolution(s);
1974 break;
1975
1976 default:
1977 break;
1978 }
1979
1980 return 1;
1981}
1982
1983/*
1984 * Server Name Resolution valid response callback
1985 * It expects:
1986 * - <nameserver>: the name server which answered the valid response
1987 * - <response>: buffer containing a valid DNS response
1988 * - <response_len>: size of <response>
1989 * It performs the following actions:
1990 * - ignore response if current ip found and server family not met
1991 * - update with first new ip found if family is met and current IP is not found
1992 * returns:
1993 * 0 on error
1994 * 1 when no error or safe ignore
1995 */
1996int snr_resolution_cb(struct dns_resolution *resolution, struct dns_nameserver *nameserver, unsigned char *response, int response_len)
1997{
1998 struct server *s;
1999 void *serverip, *firstip;
2000 short server_sin_family, firstip_sin_family;
2001 unsigned char *response_end;
2002 int ret;
2003 struct chunk *chk = get_trash_chunk();
2004
2005 /* initializing variables */
2006 response_end = response + response_len; /* pointer to mark the end of the response */
2007 firstip = NULL; /* pointer to the first valid response found */
2008 /* it will be used as the new IP if a change is required */
2009 firstip_sin_family = AF_UNSPEC;
2010 serverip = NULL; /* current server IP address */
2011
2012 /* shortcut to the server whose name is being resolved */
2013 s = (struct server *)resolution->requester;
2014
2015 /* initializing server IP pointer */
2016 server_sin_family = s->addr.ss_family;
2017 switch (server_sin_family) {
2018 case AF_INET:
2019 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
2020 break;
2021
2022 case AF_INET6:
2023 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
2024 break;
2025
2026 default:
2027 goto invalid;
2028 }
2029
2030 ret = dns_get_ip_from_response(response, response_end, resolution->hostname_dn, resolution->hostname_dn_len,
2031 serverip, server_sin_family, resolution->resolver_family_priority, &firstip,
2032 &firstip_sin_family);
2033
2034 switch (ret) {
2035 case DNS_UPD_NO:
2036 if (resolution->status != RSLV_STATUS_VALID) {
2037 resolution->status = RSLV_STATUS_VALID;
2038 resolution->last_status_change = now_ms;
2039 }
2040 goto stop_resolution;
2041
2042 case DNS_UPD_SRVIP_NOT_FOUND:
2043 goto save_ip;
2044
2045 case DNS_UPD_CNAME:
2046 if (resolution->status != RSLV_STATUS_VALID) {
2047 resolution->status = RSLV_STATUS_VALID;
2048 resolution->last_status_change = now_ms;
2049 }
2050 goto invalid;
2051
2052 default:
2053 goto invalid;
2054
2055 }
2056
2057 save_ip:
2058 nameserver->counters.update += 1;
2059 if (resolution->status != RSLV_STATUS_VALID) {
2060 resolution->status = RSLV_STATUS_VALID;
2061 resolution->last_status_change = now_ms;
2062 }
2063
2064 /* save the first ip we found */
2065 chunk_printf(chk, "%s/%s", nameserver->resolvers->id, nameserver->id);
2066 update_server_addr(s, firstip, firstip_sin_family, (char *)chk->str);
2067
2068 stop_resolution:
2069 /* update last resolution date and time */
2070 resolution->last_resolution = now_ms;
2071 /* reset current status flag */
2072 resolution->step = RSLV_STEP_NONE;
2073 /* reset values */
2074 dns_reset_resolution(resolution);
2075
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002076 dns_update_resolvers_timeout(nameserver->resolvers);
2077
2078 snr_update_srv_status(s);
2079 return 0;
2080
2081 invalid:
2082 nameserver->counters.invalid += 1;
2083 if (resolution->nb_responses >= nameserver->resolvers->count_nameservers)
2084 goto stop_resolution;
2085
2086 snr_update_srv_status(s);
2087 return 0;
2088}
2089
2090/*
2091 * Server Name Resolution error management callback
2092 * returns:
2093 * 0 on error
2094 * 1 when no error or safe ignore
2095 */
2096int snr_resolution_error_cb(struct dns_resolution *resolution, int error_code)
2097{
2098 struct server *s;
2099 struct dns_resolvers *resolvers;
Baptiste Assmann90447582015-09-02 22:20:56 +02002100 int qtype_any, res_preferred_afinet, res_preferred_afinet6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002101
2102 /* shortcut to the server whose name is being resolved */
2103 s = (struct server *)resolution->requester;
2104 resolvers = resolution->resolvers;
2105
2106 /* can be ignored if this is not the last response */
2107 if ((error_code != DNS_RESP_TIMEOUT) && (resolution->nb_responses < resolvers->count_nameservers)) {
2108 return 1;
2109 }
2110
2111 switch (error_code) {
2112 case DNS_RESP_INVALID:
2113 case DNS_RESP_WRONG_NAME:
2114 if (resolution->status != RSLV_STATUS_INVALID) {
2115 resolution->status = RSLV_STATUS_INVALID;
2116 resolution->last_status_change = now_ms;
2117 }
2118 break;
2119
2120 case DNS_RESP_ANCOUNT_ZERO:
Baptiste Assmann0df5d962015-09-02 21:58:32 +02002121 case DNS_RESP_TRUNCATED:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002122 case DNS_RESP_ERROR:
Baptiste Assmann90447582015-09-02 22:20:56 +02002123 qtype_any = resolution->query_type == DNS_RTYPE_ANY;
2124 res_preferred_afinet = resolution->resolver_family_priority == AF_INET && resolution->query_type == DNS_RTYPE_A;
2125 res_preferred_afinet6 = resolution->resolver_family_priority == AF_INET6 && resolution->query_type == DNS_RTYPE_AAAA;
2126
2127 if (qtype_any || res_preferred_afinet || res_preferred_afinet6) {
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002128 /* let's change the query type */
Baptiste Assmann90447582015-09-02 22:20:56 +02002129 if (qtype_any) {
2130 /* fallback from ANY to resolution preference */
2131 if (resolution->resolver_family_priority == AF_INET6)
2132 resolution->query_type = DNS_RTYPE_AAAA;
2133 else
2134 resolution->query_type = DNS_RTYPE_A;
2135 }
2136 else if (res_preferred_afinet6) {
2137 /* fallback from AAAA to A */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002138 resolution->query_type = DNS_RTYPE_A;
Baptiste Assmann90447582015-09-02 22:20:56 +02002139 }
2140 else if (res_preferred_afinet) {
2141 /* fallback from A to AAAA */
2142 resolution->query_type = DNS_RTYPE_AAAA;
2143 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002144
2145 dns_send_query(resolution);
2146
2147 /*
2148 * move the resolution to the last element of the FIFO queue
2149 * and update timeout wakeup based on the new first entry
2150 */
2151 if (dns_check_resolution_queue(resolvers) > 1) {
2152 /* second resolution becomes first one */
Baptiste Assmann11c4e4e2015-09-02 22:15:58 +02002153 LIST_DEL(&resolution->list);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002154 /* ex first resolution goes to the end of the queue */
2155 LIST_ADDQ(&resolvers->curr_resolution, &resolution->list);
2156 }
2157 dns_update_resolvers_timeout(resolvers);
2158 goto leave;
2159 }
2160 else {
2161 if (resolution->status != RSLV_STATUS_OTHER) {
2162 resolution->status = RSLV_STATUS_OTHER;
2163 resolution->last_status_change = now_ms;
2164 }
2165 }
2166 break;
2167
2168 case DNS_RESP_NX_DOMAIN:
2169 if (resolution->status != RSLV_STATUS_NX) {
2170 resolution->status = RSLV_STATUS_NX;
2171 resolution->last_status_change = now_ms;
2172 }
2173 break;
2174
2175 case DNS_RESP_REFUSED:
2176 if (resolution->status != RSLV_STATUS_REFUSED) {
2177 resolution->status = RSLV_STATUS_REFUSED;
2178 resolution->last_status_change = now_ms;
2179 }
2180 break;
2181
2182 case DNS_RESP_CNAME_ERROR:
2183 break;
2184
2185 case DNS_RESP_TIMEOUT:
2186 if (resolution->status != RSLV_STATUS_TIMEOUT) {
2187 resolution->status = RSLV_STATUS_TIMEOUT;
2188 resolution->last_status_change = now_ms;
2189 }
2190 break;
2191 }
2192
2193 /* update last resolution date and time */
2194 resolution->last_resolution = now_ms;
2195 /* reset current status flag */
2196 resolution->step = RSLV_STEP_NONE;
2197 /* reset values */
2198 dns_reset_resolution(resolution);
2199
2200 LIST_DEL(&resolution->list);
2201 dns_update_resolvers_timeout(resolvers);
2202
2203 leave:
2204 snr_update_srv_status(s);
2205 return 1;
2206}
2207
2208/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02002209 * Local variables:
2210 * c-indent-level: 8
2211 * c-basic-offset: 8
2212 * End:
2213 */