blob: cb59d5856652ec183c2ee0a5ecbd88734dab29be [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Health-checks functions.
3 *
Willy Tarreau26c25062009-03-08 09:38:41 +01004 * Copyright 2000-2009 Willy Tarreau <w@1wt.eu>
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02005 * Copyright 2007-2009 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 Tarreaub8816082008-01-18 12:18:15 +010014#include <assert.h>
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020015#include <ctype.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020016#include <errno.h>
17#include <fcntl.h>
18#include <stdio.h>
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +020019#include <stdlib.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020020#include <string.h>
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +020021#include <time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020022#include <unistd.h>
23#include <sys/socket.h>
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +040024#include <sys/types.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020025#include <netinet/in.h>
Willy Tarreau1274bc42009-07-15 07:16:31 +020026#include <netinet/tcp.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020027#include <arpa/inet.h>
28
Willy Tarreauc7e42382012-08-24 19:22:53 +020029#include <common/chunk.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020030#include <common/compat.h>
31#include <common/config.h>
32#include <common/mini-clist.h>
Willy Tarreau83749182007-04-15 20:56:27 +020033#include <common/standard.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020034#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020035
36#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020037
38#include <proto/backend.h>
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020039#include <proto/checks.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020040#include <proto/fd.h>
41#include <proto/log.h>
42#include <proto/queue.h>
Willy Tarreauc6f4ce82009-06-10 11:09:37 +020043#include <proto/port_range.h>
Willy Tarreau3d300592007-03-18 18:34:41 +010044#include <proto/proto_http.h>
Willy Tarreaue8c66af2008-01-13 18:40:14 +010045#include <proto/proto_tcp.h>
Willy Tarreau2b5652f2006-12-31 17:46:05 +010046#include <proto/proxy.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020047#include <proto/server.h>
Simon Hormane0d1bfb2011-06-21 14:34:58 +090048#include <proto/session.h>
Willy Tarreau9e000c62011-03-10 14:03:36 +010049#include <proto/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020050#include <proto/task.h>
51
Willy Tarreaubd741542010-03-16 18:46:54 +010052static int httpchk_expect(struct server *s, int done);
53
Simon Horman63a4a822012-03-19 07:24:41 +090054static const struct check_status check_statuses[HCHK_STATUS_SIZE] = {
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020055 [HCHK_STATUS_UNKNOWN] = { SRV_CHK_UNKNOWN, "UNK", "Unknown" },
56 [HCHK_STATUS_INI] = { SRV_CHK_UNKNOWN, "INI", "Initializing" },
57 [HCHK_STATUS_START] = { /* SPECIAL STATUS*/ },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020058
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +010059 [HCHK_STATUS_HANA] = { SRV_CHK_ERROR, "HANA", "Health analyze" },
60
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020061 [HCHK_STATUS_SOCKERR] = { SRV_CHK_ERROR, "SOCKERR", "Socket error" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020062
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020063 [HCHK_STATUS_L4OK] = { SRV_CHK_RUNNING, "L4OK", "Layer4 check passed" },
64 [HCHK_STATUS_L4TOUT] = { SRV_CHK_ERROR, "L4TOUT", "Layer4 timeout" },
65 [HCHK_STATUS_L4CON] = { SRV_CHK_ERROR, "L4CON", "Layer4 connection problem" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020066
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020067 [HCHK_STATUS_L6OK] = { SRV_CHK_RUNNING, "L6OK", "Layer6 check passed" },
68 [HCHK_STATUS_L6TOUT] = { SRV_CHK_ERROR, "L6TOUT", "Layer6 timeout" },
69 [HCHK_STATUS_L6RSP] = { SRV_CHK_ERROR, "L6RSP", "Layer6 invalid response" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020070
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020071 [HCHK_STATUS_L7TOUT] = { SRV_CHK_ERROR, "L7TOUT", "Layer7 timeout" },
72 [HCHK_STATUS_L7RSP] = { SRV_CHK_ERROR, "L7RSP", "Layer7 invalid response" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020073
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020074 [HCHK_STATUS_L57DATA] = { /* DUMMY STATUS */ },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020075
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020076 [HCHK_STATUS_L7OKD] = { SRV_CHK_RUNNING, "L7OK", "Layer7 check passed" },
77 [HCHK_STATUS_L7OKCD] = { SRV_CHK_RUNNING | SRV_CHK_DISABLE, "L7OKC", "Layer7 check conditionally passed" },
78 [HCHK_STATUS_L7STS] = { SRV_CHK_ERROR, "L7STS", "Layer7 wrong status" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020079};
80
Simon Horman63a4a822012-03-19 07:24:41 +090081static const struct analyze_status analyze_statuses[HANA_STATUS_SIZE] = { /* 0: ignore, 1: error, 2: OK */
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +010082 [HANA_STATUS_UNKNOWN] = { "Unknown", { 0, 0 }},
83
84 [HANA_STATUS_L4_OK] = { "L4 successful connection", { 2, 0 }},
85 [HANA_STATUS_L4_ERR] = { "L4 unsuccessful connection", { 1, 1 }},
86
87 [HANA_STATUS_HTTP_OK] = { "Correct http response", { 0, 2 }},
88 [HANA_STATUS_HTTP_STS] = { "Wrong http response", { 0, 1 }},
89 [HANA_STATUS_HTTP_HDRRSP] = { "Invalid http response (headers)", { 0, 1 }},
90 [HANA_STATUS_HTTP_RSP] = { "Invalid http response", { 0, 1 }},
91
92 [HANA_STATUS_HTTP_READ_ERROR] = { "Read error (http)", { 0, 1 }},
93 [HANA_STATUS_HTTP_READ_TIMEOUT] = { "Read timeout (http)", { 0, 1 }},
94 [HANA_STATUS_HTTP_BROKEN_PIPE] = { "Close from server (http)", { 0, 1 }},
95};
96
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020097/*
98 * Convert check_status code to description
99 */
100const char *get_check_status_description(short check_status) {
101
102 const char *desc;
103
104 if (check_status < HCHK_STATUS_SIZE)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200105 desc = check_statuses[check_status].desc;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200106 else
107 desc = NULL;
108
109 if (desc && *desc)
110 return desc;
111 else
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200112 return check_statuses[HCHK_STATUS_UNKNOWN].desc;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200113}
114
115/*
116 * Convert check_status code to short info
117 */
118const char *get_check_status_info(short check_status) {
119
120 const char *info;
121
122 if (check_status < HCHK_STATUS_SIZE)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200123 info = check_statuses[check_status].info;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200124 else
125 info = NULL;
126
127 if (info && *info)
128 return info;
129 else
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200130 return check_statuses[HCHK_STATUS_UNKNOWN].info;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200131}
132
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100133const char *get_analyze_status(short analyze_status) {
134
135 const char *desc;
136
137 if (analyze_status < HANA_STATUS_SIZE)
138 desc = analyze_statuses[analyze_status].desc;
139 else
140 desc = NULL;
141
142 if (desc && *desc)
143 return desc;
144 else
145 return analyze_statuses[HANA_STATUS_UNKNOWN].desc;
146}
147
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200148#define SSP_O_HCHK 0x0002
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200149
150static void server_status_printf(struct chunk *msg, struct server *s, unsigned options, int xferred) {
151
Willy Tarreau44267702011-10-28 15:35:33 +0200152 if (s->track)
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200153 chunk_printf(msg, " via %s/%s",
Willy Tarreau44267702011-10-28 15:35:33 +0200154 s->track->proxy->id, s->track->id);
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200155
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200156 if (options & SSP_O_HCHK) {
157 chunk_printf(msg, ", reason: %s", get_check_status_description(s->check_status));
158
159 if (s->check_status >= HCHK_STATUS_L57DATA)
160 chunk_printf(msg, ", code: %d", s->check_code);
161
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200162 if (*s->check_desc) {
163 struct chunk src;
164
165 chunk_printf(msg, ", info: \"");
166
167 chunk_initlen(&src, s->check_desc, 0, strlen(s->check_desc));
168 chunk_asciiencode(msg, &src, '"');
169
170 chunk_printf(msg, "\"");
171 }
172
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100173 if (s->check_duration >= 0)
174 chunk_printf(msg, ", check duration: %ldms", s->check_duration);
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200175 }
176
Krzysztof Piotr Oledzki3bb05712010-09-27 13:10:50 +0200177 if (xferred >= 0) {
Krzysztof Piotr Oledzkib16a6072010-01-10 21:12:58 +0100178 if (!(s->state & SRV_RUNNING))
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200179 chunk_printf(msg, ". %d active and %d backup servers left.%s"
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100180 " %d sessions active, %d requeued, %d remaining in queue",
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200181 s->proxy->srv_act, s->proxy->srv_bck,
182 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
183 s->cur_sess, xferred, s->nbpend);
184 else
185 chunk_printf(msg, ". %d active and %d backup servers online.%s"
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100186 " %d sessions requeued, %d total in queue",
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200187 s->proxy->srv_act, s->proxy->srv_bck,
188 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
189 xferred, s->nbpend);
190 }
191}
192
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200193/*
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200194 * Set s->check_status, update s->check_duration and fill s->result with
195 * an adequate SRV_CHK_* value.
196 *
197 * Show information in logs about failed health check if server is UP
198 * or succeeded health checks if server is DOWN.
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200199 */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200200static void set_server_check_status(struct server *s, short status, char *desc) {
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200201
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200202 struct chunk msg;
203
204 if (status == HCHK_STATUS_START) {
205 s->result = SRV_CHK_UNKNOWN; /* no result yet */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200206 s->check_desc[0] = '\0';
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200207 s->check_start = now;
208 return;
209 }
210
211 if (!s->check_status)
212 return;
213
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200214 if (desc && *desc) {
215 strncpy(s->check_desc, desc, HCHK_DESC_LEN-1);
216 s->check_desc[HCHK_DESC_LEN-1] = '\0';
217 } else
218 s->check_desc[0] = '\0';
219
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200220 s->check_status = status;
221 if (check_statuses[status].result)
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100222 s->result = check_statuses[status].result;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200223
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100224 if (status == HCHK_STATUS_HANA)
225 s->check_duration = -1;
226 else if (!tv_iszero(&s->check_start)) {
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200227 /* set_server_check_status() may be called more than once */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200228 s->check_duration = tv_ms_elapsed(&s->check_start, &now);
229 tv_zero(&s->check_start);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200230 }
231
232 if (s->proxy->options2 & PR_O2_LOGHCHKS &&
233 (((s->health != 0) && (s->result & SRV_CHK_ERROR)) ||
234 ((s->health != s->rise + s->fall - 1) && (s->result & SRV_CHK_RUNNING)) ||
235 ((s->state & SRV_GOINGDOWN) && !(s->result & SRV_CHK_DISABLE)) ||
236 (!(s->state & SRV_GOINGDOWN) && (s->result & SRV_CHK_DISABLE)))) {
237
238 int health, rise, fall, state;
239
David du Colombier7af46052012-05-16 14:16:48 +0200240 chunk_init(&msg, trash, trashlen);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200241
242 /* FIXME begin: calculate local version of the health/rise/fall/state */
243 health = s->health;
244 rise = s->rise;
245 fall = s->fall;
246 state = s->state;
247
248 if (s->result & SRV_CHK_ERROR) {
249 if (health > rise) {
250 health--; /* still good */
251 } else {
252 if (health == rise)
253 state &= ~(SRV_RUNNING | SRV_GOINGDOWN);
254
255 health = 0;
256 }
257 }
258
259 if (s->result & SRV_CHK_RUNNING) {
260 if (health < rise + fall - 1) {
261 health++; /* was bad, stays for a while */
262
263 if (health == rise)
264 state |= SRV_RUNNING;
265
266 if (health >= rise)
267 health = rise + fall - 1; /* OK now */
268 }
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100269
270 /* clear consecutive_errors if observing is enabled */
271 if (s->onerror)
272 s->consecutive_errors = 0;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200273 }
274 /* FIXME end: calculate local version of the health/rise/fall/state */
275
276 chunk_printf(&msg,
277 "Health check for %sserver %s/%s %s%s",
278 s->state & SRV_BACKUP ? "backup " : "",
279 s->proxy->id, s->id,
280 (s->result & SRV_CHK_DISABLE)?"conditionally ":"",
281 (s->result & SRV_CHK_RUNNING)?"succeeded":"failed");
282
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200283 server_status_printf(&msg, s, SSP_O_HCHK, -1);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200284
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100285 chunk_printf(&msg, ", status: %d/%d %s",
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200286 (state & SRV_RUNNING) ? (health - rise + 1) : (health),
287 (state & SRV_RUNNING) ? (fall) : (rise),
288 (state & SRV_RUNNING)?"UP":"DOWN");
289
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100290 Warning("%s.\n", trash);
291 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200292 }
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200293}
294
Willy Tarreau48494c02007-11-30 10:41:39 +0100295/* sends a log message when a backend goes down, and also sets last
296 * change date.
297 */
298static void set_backend_down(struct proxy *be)
299{
300 be->last_change = now.tv_sec;
301 be->down_trans++;
302
303 Alert("%s '%s' has no server available!\n", proxy_type_str(be), be->id);
304 send_log(be, LOG_EMERG, "%s %s has no server available!\n", proxy_type_str(be), be->id);
305}
306
307/* Redistribute pending connections when a server goes down. The number of
308 * connections redistributed is returned.
309 */
310static int redistribute_pending(struct server *s)
311{
312 struct pendconn *pc, *pc_bck, *pc_end;
313 int xferred = 0;
314
315 FOREACH_ITEM_SAFE(pc, pc_bck, &s->pendconns, pc_end, struct pendconn *, list) {
316 struct session *sess = pc->sess;
Willy Tarreau4de91492010-01-22 19:10:05 +0100317 if ((sess->be->options & (PR_O_REDISP|PR_O_PERSIST)) == PR_O_REDISP &&
318 !(sess->flags & SN_FORCE_PRST)) {
Willy Tarreau48494c02007-11-30 10:41:39 +0100319 /* The REDISP option was specified. We will ignore
320 * cookie and force to balance or use the dispatcher.
321 */
Krzysztof Piotr Oledzki25b501a2008-01-06 16:36:16 +0100322
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100323 /* it's left to the dispatcher to choose a server */
Willy Tarreau48494c02007-11-30 10:41:39 +0100324 sess->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
Krzysztof Piotr Oledzki25b501a2008-01-06 16:36:16 +0100325
Willy Tarreau48494c02007-11-30 10:41:39 +0100326 pendconn_free(pc);
Willy Tarreaufdccded2008-08-29 18:19:04 +0200327 task_wakeup(sess->task, TASK_WOKEN_RES);
Willy Tarreau48494c02007-11-30 10:41:39 +0100328 xferred++;
329 }
330 }
331 return xferred;
332}
333
334/* Check for pending connections at the backend, and assign some of them to
335 * the server coming up. The server's weight is checked before being assigned
336 * connections it may not be able to handle. The total number of transferred
337 * connections is returned.
338 */
339static int check_for_pending(struct server *s)
340{
341 int xferred;
342
343 if (!s->eweight)
344 return 0;
345
346 for (xferred = 0; !s->maxconn || xferred < srv_dynamic_maxconn(s); xferred++) {
347 struct session *sess;
348 struct pendconn *p;
349
350 p = pendconn_from_px(s->proxy);
351 if (!p)
352 break;
Willy Tarreau9e000c62011-03-10 14:03:36 +0100353 set_target_server(&p->sess->target, s);
Willy Tarreau48494c02007-11-30 10:41:39 +0100354 sess = p->sess;
355 pendconn_free(p);
Willy Tarreaufdccded2008-08-29 18:19:04 +0200356 task_wakeup(sess->task, TASK_WOKEN_RES);
Willy Tarreau48494c02007-11-30 10:41:39 +0100357 }
358 return xferred;
359}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200360
Justin Karnegeseb2c24a2012-05-24 15:28:52 -0700361/* Shutdown all connections of a server. The caller must pass a termination
362 * code in <why>, which must be one of SN_ERR_* indicating the reason for the
363 * shutdown.
Simon Hormane0d1bfb2011-06-21 14:34:58 +0900364 */
Justin Karnegeseb2c24a2012-05-24 15:28:52 -0700365static void shutdown_sessions(struct server *srv, int why)
Simon Hormane0d1bfb2011-06-21 14:34:58 +0900366{
367 struct session *session, *session_bck;
368
Willy Tarreaua2a64e92011-09-07 23:01:56 +0200369 list_for_each_entry_safe(session, session_bck, &srv->actconns, by_srv)
370 if (session->srv_conn == srv)
Justin Karnegeseb2c24a2012-05-24 15:28:52 -0700371 session_shutdown(session, why);
Simon Hormane0d1bfb2011-06-21 14:34:58 +0900372}
373
Justin Karnegeseb2c24a2012-05-24 15:28:52 -0700374/* Shutdown all connections of all backup servers of a proxy. The caller must
375 * pass a termination code in <why>, which must be one of SN_ERR_* indicating
376 * the reason for the shutdown.
377 */
378static void shutdown_backup_sessions(struct proxy *px, int why)
379{
380 struct server *srv;
381
382 for (srv = px->srv; srv != NULL; srv = srv->next)
383 if (srv->state & SRV_BACKUP)
384 shutdown_sessions(srv, why);
385}
386
Willy Tarreaubaaee002006-06-26 02:48:02 +0200387/* Sets server <s> down, notifies by all available means, recounts the
388 * remaining servers on the proxy and transfers queued sessions whenever
Willy Tarreau5af3a692007-07-24 23:32:33 +0200389 * possible to other servers. It automatically recomputes the number of
390 * servers, but not the map.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200391 */
Cyril Bontécd19e512010-01-31 22:34:03 +0100392void set_server_down(struct server *s)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200393{
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100394 struct server *srv;
395 struct chunk msg;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200396 int xferred;
397
Cyril Bontécd19e512010-01-31 22:34:03 +0100398 if (s->state & SRV_MAINTAIN) {
399 s->health = s->rise;
400 }
401
Willy Tarreau44267702011-10-28 15:35:33 +0200402 if (s->health == s->rise || s->track) {
Willy Tarreau48494c02007-11-30 10:41:39 +0100403 int srv_was_paused = s->state & SRV_GOINGDOWN;
Willy Tarreaud64d2252010-10-17 17:16:42 +0200404 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
Krzysztof Oledzki85130942007-10-22 16:21:10 +0200405
406 s->last_change = now.tv_sec;
Willy Tarreau48494c02007-11-30 10:41:39 +0100407 s->state &= ~(SRV_RUNNING | SRV_GOINGDOWN);
Willy Tarreau9580d162012-05-19 19:07:40 +0200408 if (s->proxy->lbprm.set_server_status_down)
409 s->proxy->lbprm.set_server_status_down(s);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200410
Simon Hormane0d1bfb2011-06-21 14:34:58 +0900411 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
Justin Karnegeseb2c24a2012-05-24 15:28:52 -0700412 shutdown_sessions(s, SN_ERR_DOWN);
Simon Hormane0d1bfb2011-06-21 14:34:58 +0900413
Willy Tarreaubaaee002006-06-26 02:48:02 +0200414 /* we might have sessions queued on this server and waiting for
415 * a connection. Those which are redispatchable will be queued
416 * to another server or to the proxy itself.
417 */
Willy Tarreau48494c02007-11-30 10:41:39 +0100418 xferred = redistribute_pending(s);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100419
David du Colombier7af46052012-05-16 14:16:48 +0200420 chunk_init(&msg, trash, trashlen);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100421
Cyril Bontécd19e512010-01-31 22:34:03 +0100422 if (s->state & SRV_MAINTAIN) {
423 chunk_printf(&msg,
424 "%sServer %s/%s is DOWN for maintenance", s->state & SRV_BACKUP ? "Backup " : "",
425 s->proxy->id, s->id);
426 } else {
427 chunk_printf(&msg,
428 "%sServer %s/%s is DOWN", s->state & SRV_BACKUP ? "Backup " : "",
429 s->proxy->id, s->id);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100430
Cyril Bontécd19e512010-01-31 22:34:03 +0100431 server_status_printf(&msg, s,
Willy Tarreau44267702011-10-28 15:35:33 +0200432 ((!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS))?SSP_O_HCHK:0),
Cyril Bontécd19e512010-01-31 22:34:03 +0100433 xferred);
434 }
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100435 Warning("%s.\n", trash);
Krzysztof Oledzki85130942007-10-22 16:21:10 +0200436
Willy Tarreau48494c02007-11-30 10:41:39 +0100437 /* we don't send an alert if the server was previously paused */
438 if (srv_was_paused)
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100439 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Willy Tarreau48494c02007-11-30 10:41:39 +0100440 else
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100441 send_log(s->proxy, LOG_ALERT, "%s.\n", trash);
Krzysztof Oledzki85130942007-10-22 16:21:10 +0200442
Willy Tarreaud64d2252010-10-17 17:16:42 +0200443 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
Willy Tarreau48494c02007-11-30 10:41:39 +0100444 set_backend_down(s->proxy);
445
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200446 s->counters.down_trans++;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100447
Krzysztof Piotr Oledzkif39c71c2009-01-30 00:52:49 +0100448 if (s->state & SRV_CHECKED)
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100449 for(srv = s->tracknext; srv; srv = srv->tracknext)
Cyril Bontécd19e512010-01-31 22:34:03 +0100450 if (! (srv->state & SRV_MAINTAIN))
451 /* Only notify tracking servers that are not already in maintenance. */
452 set_server_down(srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200453 }
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100454
Willy Tarreaubaaee002006-06-26 02:48:02 +0200455 s->health = 0; /* failure */
456}
457
Cyril Bontécd19e512010-01-31 22:34:03 +0100458void set_server_up(struct server *s) {
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100459
460 struct server *srv;
461 struct chunk msg;
462 int xferred;
Willy Tarreau45446782012-03-09 17:16:09 +0100463 unsigned int old_state = s->state;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100464
Cyril Bontécd19e512010-01-31 22:34:03 +0100465 if (s->state & SRV_MAINTAIN) {
466 s->health = s->rise;
467 }
468
Willy Tarreau44267702011-10-28 15:35:33 +0200469 if (s->health == s->rise || s->track) {
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100470 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
471 if (s->proxy->last_change < now.tv_sec) // ignore negative times
472 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
473 s->proxy->last_change = now.tv_sec;
474 }
475
476 if (s->last_change < now.tv_sec) // ignore negative times
477 s->down_time += now.tv_sec - s->last_change;
478
479 s->last_change = now.tv_sec;
480 s->state |= SRV_RUNNING;
Willy Tarreau45446782012-03-09 17:16:09 +0100481 s->state &= ~SRV_MAINTAIN;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100482
483 if (s->slowstart > 0) {
484 s->state |= SRV_WARMINGUP;
485 if (s->proxy->lbprm.algo & BE_LB_PROP_DYN) {
486 /* For dynamic algorithms, start at the first step of the weight,
487 * without multiplying by BE_WEIGHT_SCALE.
488 */
489 s->eweight = s->uweight;
490 if (s->proxy->lbprm.update_server_eweight)
491 s->proxy->lbprm.update_server_eweight(s);
492 }
Willy Tarreau2e993902011-10-31 11:53:20 +0100493 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100494 }
Willy Tarreau9580d162012-05-19 19:07:40 +0200495 if (s->proxy->lbprm.set_server_status_up)
496 s->proxy->lbprm.set_server_status_up(s);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100497
Justin Karnegeseb2c24a2012-05-24 15:28:52 -0700498 /* If the server is set with "on-marked-up shutdown-backup-sessions",
499 * and it's not a backup server and its effective weight is > 0,
500 * then it can accept new connections, so we shut down all sessions
501 * on all backup servers.
502 */
503 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
504 !(s->state & SRV_BACKUP) && s->eweight)
505 shutdown_backup_sessions(s->proxy, SN_ERR_UP);
506
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100507 /* check if we can handle some connections queued at the proxy. We
508 * will take as many as we can handle.
509 */
510 xferred = check_for_pending(s);
511
David du Colombier7af46052012-05-16 14:16:48 +0200512 chunk_init(&msg, trash, trashlen);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100513
Willy Tarreau45446782012-03-09 17:16:09 +0100514 if (old_state & SRV_MAINTAIN) {
Cyril Bontécd19e512010-01-31 22:34:03 +0100515 chunk_printf(&msg,
516 "%sServer %s/%s is UP (leaving maintenance)", s->state & SRV_BACKUP ? "Backup " : "",
517 s->proxy->id, s->id);
518 } else {
519 chunk_printf(&msg,
520 "%sServer %s/%s is UP", s->state & SRV_BACKUP ? "Backup " : "",
521 s->proxy->id, s->id);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100522
Cyril Bontécd19e512010-01-31 22:34:03 +0100523 server_status_printf(&msg, s,
Willy Tarreau44267702011-10-28 15:35:33 +0200524 ((!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS))?SSP_O_HCHK:0),
Cyril Bontécd19e512010-01-31 22:34:03 +0100525 xferred);
526 }
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100527
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100528 Warning("%s.\n", trash);
529 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100530
Krzysztof Piotr Oledzkif39c71c2009-01-30 00:52:49 +0100531 if (s->state & SRV_CHECKED)
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100532 for(srv = s->tracknext; srv; srv = srv->tracknext)
Cyril Bontécd19e512010-01-31 22:34:03 +0100533 if (! (srv->state & SRV_MAINTAIN))
534 /* Only notify tracking servers if they're not in maintenance. */
535 set_server_up(srv);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100536 }
537
538 if (s->health >= s->rise)
539 s->health = s->rise + s->fall - 1; /* OK now */
540
541}
542
543static void set_server_disabled(struct server *s) {
544
545 struct server *srv;
546 struct chunk msg;
547 int xferred;
548
549 s->state |= SRV_GOINGDOWN;
Willy Tarreau9580d162012-05-19 19:07:40 +0200550 if (s->proxy->lbprm.set_server_status_down)
551 s->proxy->lbprm.set_server_status_down(s);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100552
553 /* we might have sessions queued on this server and waiting for
554 * a connection. Those which are redispatchable will be queued
555 * to another server or to the proxy itself.
556 */
557 xferred = redistribute_pending(s);
558
David du Colombier7af46052012-05-16 14:16:48 +0200559 chunk_init(&msg, trash, trashlen);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100560
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200561 chunk_printf(&msg,
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100562 "Load-balancing on %sServer %s/%s is disabled",
563 s->state & SRV_BACKUP ? "Backup " : "",
564 s->proxy->id, s->id);
565
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200566 server_status_printf(&msg, s,
Willy Tarreau44267702011-10-28 15:35:33 +0200567 ((!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS))?SSP_O_HCHK:0),
Krzysztof Piotr Oledzkib16a6072010-01-10 21:12:58 +0100568 xferred);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100569
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100570 Warning("%s.\n", trash);
571 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100572
573 if (!s->proxy->srv_bck && !s->proxy->srv_act)
574 set_backend_down(s->proxy);
575
Krzysztof Piotr Oledzkif39c71c2009-01-30 00:52:49 +0100576 if (s->state & SRV_CHECKED)
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100577 for(srv = s->tracknext; srv; srv = srv->tracknext)
578 set_server_disabled(srv);
579}
580
581static void set_server_enabled(struct server *s) {
582
583 struct server *srv;
584 struct chunk msg;
585 int xferred;
586
587 s->state &= ~SRV_GOINGDOWN;
Willy Tarreau9580d162012-05-19 19:07:40 +0200588 if (s->proxy->lbprm.set_server_status_up)
589 s->proxy->lbprm.set_server_status_up(s);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100590
591 /* check if we can handle some connections queued at the proxy. We
592 * will take as many as we can handle.
593 */
594 xferred = check_for_pending(s);
595
David du Colombier7af46052012-05-16 14:16:48 +0200596 chunk_init(&msg, trash, trashlen);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100597
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200598 chunk_printf(&msg,
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100599 "Load-balancing on %sServer %s/%s is enabled again",
600 s->state & SRV_BACKUP ? "Backup " : "",
601 s->proxy->id, s->id);
602
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200603 server_status_printf(&msg, s,
Willy Tarreau44267702011-10-28 15:35:33 +0200604 ((!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS))?SSP_O_HCHK:0),
Krzysztof Piotr Oledzkib16a6072010-01-10 21:12:58 +0100605 xferred);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100606
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100607 Warning("%s.\n", trash);
608 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100609
Krzysztof Piotr Oledzkif39c71c2009-01-30 00:52:49 +0100610 if (s->state & SRV_CHECKED)
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100611 for(srv = s->tracknext; srv; srv = srv->tracknext)
612 set_server_enabled(srv);
613}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200614
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100615void health_adjust(struct server *s, short status) {
616
617 int failed;
618 int expire;
619
620 /* return now if observing nor health check is not enabled */
621 if (!s->observe || !s->check)
622 return;
623
624 if (s->observe >= HANA_OBS_SIZE)
625 return;
626
627 if (status >= HCHK_STATUS_SIZE || !analyze_statuses[status].desc)
628 return;
629
630 switch (analyze_statuses[status].lr[s->observe - 1]) {
631 case 1:
632 failed = 1;
633 break;
634
635 case 2:
636 failed = 0;
637 break;
638
639 default:
640 return;
641 }
642
643 if (!failed) {
644 /* good: clear consecutive_errors */
645 s->consecutive_errors = 0;
646 return;
647 }
648
649 s->consecutive_errors++;
650
651 if (s->consecutive_errors < s->consecutive_errors_limit)
652 return;
653
654 sprintf(trash, "Detected %d consecutive errors, last one was: %s",
655 s->consecutive_errors, get_analyze_status(status));
656
657 switch (s->onerror) {
658 case HANA_ONERR_FASTINTER:
659 /* force fastinter - nothing to do here as all modes force it */
660 break;
661
662 case HANA_ONERR_SUDDTH:
663 /* simulate a pre-fatal failed health check */
664 if (s->health > s->rise)
665 s->health = s->rise + 1;
666
667 /* no break - fall through */
668
669 case HANA_ONERR_FAILCHK:
670 /* simulate a failed health check */
671 set_server_check_status(s, HCHK_STATUS_HANA, trash);
672
673 if (s->health > s->rise) {
674 s->health--; /* still good */
675 s->counters.failed_checks++;
676 }
677 else
678 set_server_down(s);
679
680 break;
681
682 case HANA_ONERR_MARKDWN:
683 /* mark server down */
684 s->health = s->rise;
685 set_server_check_status(s, HCHK_STATUS_HANA, trash);
686 set_server_down(s);
687
688 break;
689
690 default:
691 /* write a warning? */
692 break;
693 }
694
695 s->consecutive_errors = 0;
696 s->counters.failed_hana++;
697
698 if (s->fastinter) {
699 expire = tick_add(now_ms, MS_TO_TICKS(s->fastinter));
700 if (s->check->expire > expire)
701 s->check->expire = expire;
702 }
703}
704
Willy Tarreauef781042010-01-27 11:53:01 +0100705static int httpchk_build_status_header(struct server *s, char *buffer)
706{
707 int sv_state;
708 int ratio;
709 int hlen = 0;
710 const char *srv_hlt_st[7] = { "DOWN", "DOWN %d/%d",
711 "UP %d/%d", "UP",
712 "NOLB %d/%d", "NOLB",
713 "no check" };
714
715 memcpy(buffer + hlen, "X-Haproxy-Server-State: ", 24);
716 hlen += 24;
717
718 if (!(s->state & SRV_CHECKED))
719 sv_state = 6; /* should obviously never happen */
720 else if (s->state & SRV_RUNNING) {
721 if (s->health == s->rise + s->fall - 1)
722 sv_state = 3; /* UP */
723 else
724 sv_state = 2; /* going down */
725
726 if (s->state & SRV_GOINGDOWN)
727 sv_state += 2;
728 } else {
729 if (s->health)
730 sv_state = 1; /* going up */
731 else
732 sv_state = 0; /* DOWN */
733 }
734
735 hlen += sprintf(buffer + hlen,
736 srv_hlt_st[sv_state],
737 (s->state & SRV_RUNNING) ? (s->health - s->rise + 1) : (s->health),
738 (s->state & SRV_RUNNING) ? (s->fall) : (s->rise));
739
740 hlen += sprintf(buffer + hlen, "; name=%s/%s; node=%s; weight=%d/%d; scur=%d/%d; qcur=%d",
741 s->proxy->id, s->id,
742 global.node,
743 (s->eweight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv,
744 (s->proxy->lbprm.tot_weight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv,
745 s->cur_sess, s->proxy->beconn - s->proxy->nbpend,
746 s->nbpend);
747
748 if ((s->state & SRV_WARMINGUP) &&
749 now.tv_sec < s->last_change + s->slowstart &&
750 now.tv_sec >= s->last_change) {
751 ratio = MAX(1, 100 * (now.tv_sec - s->last_change) / s->slowstart);
752 hlen += sprintf(buffer + hlen, "; throttle=%d%%", ratio);
753 }
754
755 buffer[hlen++] = '\r';
756 buffer[hlen++] = '\n';
757
758 return hlen;
759}
760
Willy Tarreaubaaee002006-06-26 02:48:02 +0200761/*
762 * This function is used only for server health-checks. It handles
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200763 * the connection acknowledgement. If the proxy requires L7 health-checks,
764 * it sends the request. In other cases, it calls set_server_check_status()
765 * to set s->check_status, s->check_duration and s->result.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200766 */
Willy Tarreau3267d362012-08-17 23:53:56 +0200767static void event_srv_chk_w(int fd)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200768{
Willy Tarreau6996e152007-04-30 14:37:43 +0200769 __label__ out_wakeup, out_nowake, out_poll, out_error;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200770 struct task *t = fdtab[fd].owner;
771 struct server *s = t->context;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200772
Willy Tarreau505e34a2012-07-06 10:17:53 +0200773 if (unlikely((s->check_conn->flags & CO_FL_ERROR) || (fdtab[fd].ev & FD_POLL_ERR))) {
Krzysztof Piotr Oledzki6492db52010-01-02 22:03:01 +0100774 int skerr, err = errno;
775 socklen_t lskerr = sizeof(skerr);
776
777 if (!getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr) && skerr)
778 err = skerr;
779
780 set_server_check_status(s, HCHK_STATUS_L4CON, strerror(err));
Willy Tarreau6996e152007-04-30 14:37:43 +0200781 goto out_error;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200782 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200783
784 /* here, we know that the connection is established */
Willy Tarreau83749182007-04-15 20:56:27 +0200785
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100786 if (!(s->result & SRV_CHK_ERROR)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200787 /* we don't want to mark 'UP' a server on which we detected an error earlier */
Willy Tarreau1620ec32011-08-06 17:05:02 +0200788 if (s->proxy->options2 & PR_O2_CHK_ANY) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200789 int ret;
Willy Tarreaue9d87882010-01-27 11:28:42 +0100790 const char *check_req = s->proxy->check_req;
791 int check_len = s->proxy->check_len;
792
Willy Tarreauf3c69202006-07-09 16:42:34 +0200793 /* we want to check if this host replies to HTTP or SSLv3 requests
Willy Tarreaubaaee002006-06-26 02:48:02 +0200794 * so we'll send the request, and won't wake the checker up now.
795 */
Willy Tarreauf3c69202006-07-09 16:42:34 +0200796
Willy Tarreau1620ec32011-08-06 17:05:02 +0200797 if ((s->proxy->options2 & PR_O2_CHK_ANY) == PR_O2_SSL3_CHK) {
Willy Tarreauf3c69202006-07-09 16:42:34 +0200798 /* SSL requires that we put Unix time in the request */
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200799 int gmt_time = htonl(date.tv_sec);
Willy Tarreauf3c69202006-07-09 16:42:34 +0200800 memcpy(s->proxy->check_req + 11, &gmt_time, 4);
801 }
Willy Tarreau1620ec32011-08-06 17:05:02 +0200802 else if ((s->proxy->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK) {
Willy Tarreaue9d87882010-01-27 11:28:42 +0100803 memcpy(trash, check_req, check_len);
Willy Tarreauef781042010-01-27 11:53:01 +0100804
805 if (s->proxy->options2 & PR_O2_CHK_SNDST)
806 check_len += httpchk_build_status_header(s, trash + check_len);
807
Willy Tarreaue9d87882010-01-27 11:28:42 +0100808 trash[check_len++] = '\r';
809 trash[check_len++] = '\n';
810 trash[check_len] = '\0';
811 check_req = trash;
812 }
Willy Tarreauf3c69202006-07-09 16:42:34 +0200813
Willy Tarreaue9d87882010-01-27 11:28:42 +0100814 ret = send(fd, check_req, check_len, MSG_DONTWAIT | MSG_NOSIGNAL);
815 if (ret == check_len) {
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100816 /* we allow up to <timeout.check> if nonzero for a responce */
Willy Tarreau1e44a492012-05-25 07:41:38 +0200817 if (s->proxy->timeout.check) {
Willy Tarreau7cd9d942008-12-21 13:00:41 +0100818 t->expire = tick_add_ifset(now_ms, s->proxy->timeout.check);
Willy Tarreau1e44a492012-05-25 07:41:38 +0200819 task_queue(t);
820 }
Willy Tarreau49b046d2012-08-09 12:11:58 +0200821 fd_want_recv(fd); /* prepare for reading reply */
Willy Tarreau83749182007-04-15 20:56:27 +0200822 goto out_nowake;
823 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200824 else if (ret == 0 || errno == EAGAIN)
825 goto out_poll;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200826 else {
827 switch (errno) {
828 case ECONNREFUSED:
829 case ENETUNREACH:
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200830 set_server_check_status(s, HCHK_STATUS_L4CON, strerror(errno));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200831 break;
832
833 default:
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200834 set_server_check_status(s, HCHK_STATUS_SOCKERR, strerror(errno));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200835 }
836
Willy Tarreau6996e152007-04-30 14:37:43 +0200837 goto out_error;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200838 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200839 }
840 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200841 /* We have no data to send to check the connection, and
842 * getsockopt() will not inform us whether the connection
843 * is still pending. So we'll reuse connect() to check the
844 * state of the socket. This has the advantage of givig us
845 * the following info :
846 * - error
847 * - connecting (EALREADY, EINPROGRESS)
848 * - connected (EISCONN, 0)
849 */
850
David du Colombier6f5ccb12011-03-10 22:26:24 +0100851 struct sockaddr_storage sa;
Willy Tarreau6996e152007-04-30 14:37:43 +0200852
David du Colombier6f5ccb12011-03-10 22:26:24 +0100853 if (is_addr(&s->check_addr))
854 sa = s->check_addr;
855 else
856 sa = s->addr;
857
Willy Tarreau1b4b7ce2011-04-05 16:56:50 +0200858 set_host_port(&sa, s->check_port);
Willy Tarreau6996e152007-04-30 14:37:43 +0200859
Willy Tarreau1b4b7ce2011-04-05 16:56:50 +0200860 if (connect(fd, (struct sockaddr *)&sa, get_addr_len(&sa)) == 0)
Willy Tarreau6996e152007-04-30 14:37:43 +0200861 errno = 0;
862
863 if (errno == EALREADY || errno == EINPROGRESS)
864 goto out_poll;
865
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200866 if (errno && errno != EISCONN) {
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200867 set_server_check_status(s, HCHK_STATUS_L4CON, strerror(errno));
Willy Tarreau6996e152007-04-30 14:37:43 +0200868 goto out_error;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200869 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200870
Willy Tarreaubaaee002006-06-26 02:48:02 +0200871 /* good TCP connection is enough */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200872 set_server_check_status(s, HCHK_STATUS_L4OK, NULL);
Willy Tarreau6996e152007-04-30 14:37:43 +0200873 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200874 }
875 }
Willy Tarreau83749182007-04-15 20:56:27 +0200876 out_wakeup:
Willy Tarreaufdccded2008-08-29 18:19:04 +0200877 task_wakeup(t, TASK_WOKEN_IO);
Willy Tarreau83749182007-04-15 20:56:27 +0200878 out_nowake:
Willy Tarreau49b046d2012-08-09 12:11:58 +0200879 fd_stop_send(fd); /* nothing more to write */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100880 fdtab[fd].ev &= ~FD_POLL_OUT;
Willy Tarreau3267d362012-08-17 23:53:56 +0200881 return;
Willy Tarreau6996e152007-04-30 14:37:43 +0200882 out_poll:
883 /* The connection is still pending. We'll have to poll it
884 * before attempting to go further. */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100885 fdtab[fd].ev &= ~FD_POLL_OUT;
Willy Tarreau3267d362012-08-17 23:53:56 +0200886 fd_poll_send(fd);
887 return;
Willy Tarreau6996e152007-04-30 14:37:43 +0200888 out_error:
Willy Tarreau505e34a2012-07-06 10:17:53 +0200889 s->check_conn->flags |= CO_FL_ERROR;
Willy Tarreau6996e152007-04-30 14:37:43 +0200890 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200891}
892
893
894/*
Willy Tarreauf3c69202006-07-09 16:42:34 +0200895 * This function is used only for server health-checks. It handles the server's
Hervé COMMOWICK8776f1b2010-10-18 15:58:36 +0200896 * reply to an HTTP request, SSL HELLO or MySQL client Auth. It calls
897 * set_server_check_status() to update s->check_status, s->check_duration
898 * and s->result.
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200899
900 * The set_server_check_status function is called with HCHK_STATUS_L7OKD if
901 * an HTTP server replies HTTP 2xx or 3xx (valid responses), if an SMTP server
902 * returns 2xx, HCHK_STATUS_L6OK if an SSL server returns at least 5 bytes in
903 * response to an SSL HELLO (the principle is that this is enough to
904 * distinguish between an SSL server and a pure TCP relay). All other cases will
905 * call it with a proper error status like HCHK_STATUS_L7STS, HCHK_STATUS_L6RSP,
906 * etc.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200907 */
Willy Tarreau3267d362012-08-17 23:53:56 +0200908static void event_srv_chk_r(int fd)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200909{
Willy Tarreau83749182007-04-15 20:56:27 +0200910 __label__ out_wakeup;
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100911 int len;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200912 struct task *t = fdtab[fd].owner;
913 struct server *s = t->context;
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200914 char *desc;
Willy Tarreau03938182010-03-17 21:52:07 +0100915 int done;
Gabor Lekenyb4c81e42010-09-29 18:17:05 +0200916 unsigned short msglen;
Willy Tarreau83749182007-04-15 20:56:27 +0200917
Willy Tarreau505e34a2012-07-06 10:17:53 +0200918 if (unlikely((s->result & SRV_CHK_ERROR) || (s->check_conn->flags & CO_FL_ERROR))) {
Willy Tarreau83749182007-04-15 20:56:27 +0200919 /* in case of TCP only, this tells us if the connection failed */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200920 if (!(s->result & SRV_CHK_ERROR))
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200921 set_server_check_status(s, HCHK_STATUS_SOCKERR, NULL);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200922
Willy Tarreau83749182007-04-15 20:56:27 +0200923 goto out_wakeup;
924 }
925
Willy Tarreau83749182007-04-15 20:56:27 +0200926 /* Warning! Linux returns EAGAIN on SO_ERROR if data are still available
927 * but the connection was closed on the remote end. Fortunately, recv still
928 * works correctly and we don't need to do the getsockopt() on linux.
929 */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000930
931 /* Set buffer to point to the end of the data already read, and check
932 * that there is free space remaining. If the buffer is full, proceed
933 * with running the checks without attempting another socket read.
934 */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000935
Willy Tarreau03938182010-03-17 21:52:07 +0100936 done = 0;
Willy Tarreau43961d52010-10-04 20:39:20 +0200937 for (len = 0; s->check_data_len < global.tune.chksize; s->check_data_len += len) {
938 len = recv(fd, s->check_data + s->check_data_len, global.tune.chksize - s->check_data_len, 0);
Willy Tarreau2c7ace02010-03-16 20:32:04 +0100939 if (len <= 0)
940 break;
941 }
Nick Chalk57b1bf72010-03-16 15:50:46 +0000942
Willy Tarreau03938182010-03-17 21:52:07 +0100943 if (len == 0)
944 done = 1; /* connection hangup received */
945 else if (len < 0 && errno != EAGAIN) {
Willy Tarreauc1a07962010-03-16 20:55:43 +0100946 /* Report network errors only if we got no other data. Otherwise
947 * we'll let the upper layers decide whether the response is OK
948 * or not. It is very common that an RST sent by the server is
949 * reported as an error just after the last data chunk.
950 */
Willy Tarreau03938182010-03-17 21:52:07 +0100951 done = 1;
Willy Tarreauc1a07962010-03-16 20:55:43 +0100952 if (!s->check_data_len) {
953 if (!(s->result & SRV_CHK_ERROR))
954 set_server_check_status(s, HCHK_STATUS_SOCKERR, NULL);
955 goto out_wakeup;
956 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200957 }
958
Willy Tarreau03938182010-03-17 21:52:07 +0100959 /* Intermediate or complete response received.
960 * Terminate string in check_data buffer.
961 */
Willy Tarreau43961d52010-10-04 20:39:20 +0200962 if (s->check_data_len < global.tune.chksize)
Willy Tarreau2c7ace02010-03-16 20:32:04 +0100963 s->check_data[s->check_data_len] = '\0';
Willy Tarreau03938182010-03-17 21:52:07 +0100964 else {
Willy Tarreau2c7ace02010-03-16 20:32:04 +0100965 s->check_data[s->check_data_len - 1] = '\0';
Willy Tarreau03938182010-03-17 21:52:07 +0100966 done = 1; /* buffer full, don't wait for more data */
967 }
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200968
Nick Chalk57b1bf72010-03-16 15:50:46 +0000969 /* Run the checks... */
Willy Tarreau1620ec32011-08-06 17:05:02 +0200970 switch (s->proxy->options2 & PR_O2_CHK_ANY) {
971 case PR_O2_HTTP_CHK:
Willy Tarreau03938182010-03-17 21:52:07 +0100972 if (!done && s->check_data_len < strlen("HTTP/1.0 000\r"))
973 goto wait_more_data;
974
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100975 /* Check if the server speaks HTTP 1.X */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000976 if ((s->check_data_len < strlen("HTTP/1.0 000\r")) ||
977 (memcmp(s->check_data, "HTTP/1.", 7) != 0 ||
978 (*(s->check_data + 12) != ' ' && *(s->check_data + 12) != '\r')) ||
979 !isdigit((unsigned char) *(s->check_data + 9)) || !isdigit((unsigned char) *(s->check_data + 10)) ||
980 !isdigit((unsigned char) *(s->check_data + 11))) {
981 cut_crlf(s->check_data);
982 set_server_check_status(s, HCHK_STATUS_L7RSP, s->check_data);
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200983
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100984 goto out_wakeup;
985 }
986
Nick Chalk57b1bf72010-03-16 15:50:46 +0000987 s->check_code = str2uic(s->check_data + 9);
Nick Chalk57b1bf72010-03-16 15:50:46 +0000988 desc = ltrim(s->check_data + 12, ' ');
989
Willy Tarreaubd741542010-03-16 18:46:54 +0100990 if ((s->proxy->options & PR_O_DISABLE404) &&
991 (s->state & SRV_RUNNING) && (s->check_code == 404)) {
Nick Chalk57b1bf72010-03-16 15:50:46 +0000992 /* 404 may be accepted as "stopping" only if the server was up */
993 cut_crlf(desc);
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200994 set_server_check_status(s, HCHK_STATUS_L7OKCD, desc);
Nick Chalk57b1bf72010-03-16 15:50:46 +0000995 }
Willy Tarreaubd741542010-03-16 18:46:54 +0100996 else if (s->proxy->options2 & PR_O2_EXP_TYPE) {
997 /* Run content verification check... We know we have at least 13 chars */
998 if (!httpchk_expect(s, done))
999 goto wait_more_data;
1000 }
1001 /* check the reply : HTTP/1.X 2xx and 3xx are OK */
1002 else if (*(s->check_data + 9) == '2' || *(s->check_data + 9) == '3') {
1003 cut_crlf(desc);
1004 set_server_check_status(s, HCHK_STATUS_L7OKD, desc);
1005 }
Nick Chalk57b1bf72010-03-16 15:50:46 +00001006 else {
1007 cut_crlf(desc);
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001008 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
Nick Chalk57b1bf72010-03-16 15:50:46 +00001009 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02001010 break;
1011
1012 case PR_O2_SSL3_CHK:
Willy Tarreau03938182010-03-17 21:52:07 +01001013 if (!done && s->check_data_len < 5)
1014 goto wait_more_data;
1015
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001016 /* Check for SSLv3 alert or handshake */
Nick Chalk57b1bf72010-03-16 15:50:46 +00001017 if ((s->check_data_len >= 5) && (*s->check_data == 0x15 || *s->check_data == 0x16))
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001018 set_server_check_status(s, HCHK_STATUS_L6OK, NULL);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +02001019 else
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001020 set_server_check_status(s, HCHK_STATUS_L6RSP, NULL);
Willy Tarreau1620ec32011-08-06 17:05:02 +02001021 break;
1022
1023 case PR_O2_SMTP_CHK:
Willy Tarreau03938182010-03-17 21:52:07 +01001024 if (!done && s->check_data_len < strlen("000\r"))
1025 goto wait_more_data;
1026
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001027 /* Check if the server speaks SMTP */
Nick Chalk57b1bf72010-03-16 15:50:46 +00001028 if ((s->check_data_len < strlen("000\r")) ||
1029 (*(s->check_data + 3) != ' ' && *(s->check_data + 3) != '\r') ||
1030 !isdigit((unsigned char) *s->check_data) || !isdigit((unsigned char) *(s->check_data + 1)) ||
1031 !isdigit((unsigned char) *(s->check_data + 2))) {
1032 cut_crlf(s->check_data);
1033 set_server_check_status(s, HCHK_STATUS_L7RSP, s->check_data);
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001034
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001035 goto out_wakeup;
1036 }
1037
Nick Chalk57b1bf72010-03-16 15:50:46 +00001038 s->check_code = str2uic(s->check_data);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001039
Nick Chalk57b1bf72010-03-16 15:50:46 +00001040 desc = ltrim(s->check_data + 3, ' ');
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001041 cut_crlf(desc);
1042
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001043 /* Check for SMTP code 2xx (should be 250) */
Nick Chalk57b1bf72010-03-16 15:50:46 +00001044 if (*s->check_data == '2')
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001045 set_server_check_status(s, HCHK_STATUS_L7OKD, desc);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +02001046 else
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001047 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
Willy Tarreau1620ec32011-08-06 17:05:02 +02001048 break;
1049
1050 case PR_O2_PGSQL_CHK:
Rauf Kuliyev38b41562011-01-04 15:14:13 +01001051 if (!done && s->check_data_len < 9)
1052 goto wait_more_data;
1053
1054 if (s->check_data[0] == 'R') {
1055 set_server_check_status(s, HCHK_STATUS_L7OKD, "PostgreSQL server is ok");
1056 }
1057 else {
1058 if ((s->check_data[0] == 'E') && (s->check_data[5]!=0) && (s->check_data[6]!=0))
1059 desc = &s->check_data[6];
1060 else
1061 desc = "PostgreSQL unknown error";
1062
1063 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
1064 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02001065 break;
1066
1067 case PR_O2_REDIS_CHK:
Hervé COMMOWICKec032d62011-08-05 16:23:48 +02001068 if (!done && s->check_data_len < 7)
1069 goto wait_more_data;
1070
1071 if (strcmp(s->check_data, "+PONG\r\n") == 0) {
1072 set_server_check_status(s, HCHK_STATUS_L7OKD, "Redis server is ok");
1073 }
1074 else {
1075 set_server_check_status(s, HCHK_STATUS_L7STS, s->check_data);
1076 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02001077 break;
1078
1079 case PR_O2_MYSQL_CHK:
Willy Tarreau03938182010-03-17 21:52:07 +01001080 if (!done && s->check_data_len < 5)
1081 goto wait_more_data;
1082
Hervé COMMOWICK8776f1b2010-10-18 15:58:36 +02001083 if (s->proxy->check_len == 0) { // old mode
1084 if (*(s->check_data + 4) != '\xff') {
1085 /* We set the MySQL Version in description for information purpose
1086 * FIXME : it can be cool to use MySQL Version for other purpose,
1087 * like mark as down old MySQL server.
1088 */
1089 if (s->check_data_len > 51) {
1090 desc = ltrim(s->check_data + 5, ' ');
1091 set_server_check_status(s, HCHK_STATUS_L7OKD, desc);
1092 }
1093 else {
1094 if (!done)
1095 goto wait_more_data;
1096 /* it seems we have a OK packet but without a valid length,
1097 * it must be a protocol error
1098 */
1099 set_server_check_status(s, HCHK_STATUS_L7RSP, s->check_data);
1100 }
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001101 }
1102 else {
Hervé COMMOWICK8776f1b2010-10-18 15:58:36 +02001103 /* An error message is attached in the Error packet */
1104 desc = ltrim(s->check_data + 7, ' ');
1105 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
1106 }
1107 } else {
1108 unsigned int first_packet_len = ((unsigned int) *s->check_data) +
1109 (((unsigned int) *(s->check_data + 1)) << 8) +
1110 (((unsigned int) *(s->check_data + 2)) << 16);
1111
1112 if (s->check_data_len == first_packet_len + 4) {
1113 /* MySQL Error packet always begin with field_count = 0xff */
1114 if (*(s->check_data + 4) != '\xff') {
1115 /* We have only one MySQL packet and it is a Handshake Initialization packet
1116 * but we need to have a second packet to know if it is alright
1117 */
1118 if (!done && s->check_data_len < first_packet_len + 5)
1119 goto wait_more_data;
1120 }
1121 else {
1122 /* We have only one packet and it is an Error packet,
1123 * an error message is attached, so we can display it
1124 */
1125 desc = &s->check_data[7];
1126 //Warning("onlyoneERR: %s\n", desc);
1127 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
1128 }
1129 } else if (s->check_data_len > first_packet_len + 4) {
1130 unsigned int second_packet_len = ((unsigned int) *(s->check_data + first_packet_len + 4)) +
1131 (((unsigned int) *(s->check_data + first_packet_len + 5)) << 8) +
1132 (((unsigned int) *(s->check_data + first_packet_len + 6)) << 16);
1133
1134 if (s->check_data_len == first_packet_len + 4 + second_packet_len + 4 ) {
1135 /* We have 2 packets and that's good */
1136 /* Check if the second packet is a MySQL Error packet or not */
1137 if (*(s->check_data + first_packet_len + 8) != '\xff') {
1138 /* No error packet */
1139 /* We set the MySQL Version in description for information purpose */
1140 desc = &s->check_data[5];
1141 //Warning("2packetOK: %s\n", desc);
1142 set_server_check_status(s, HCHK_STATUS_L7OKD, desc);
1143 }
1144 else {
1145 /* An error message is attached in the Error packet
1146 * so we can display it ! :)
1147 */
1148 desc = &s->check_data[first_packet_len+11];
1149 //Warning("2packetERR: %s\n", desc);
1150 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
1151 }
1152 }
1153 }
1154 else {
Willy Tarreau03938182010-03-17 21:52:07 +01001155 if (!done)
1156 goto wait_more_data;
Hervé COMMOWICK8776f1b2010-10-18 15:58:36 +02001157 /* it seems we have a Handshake Initialization packet but without a valid length,
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001158 * it must be a protocol error
1159 */
Hervé COMMOWICK8776f1b2010-10-18 15:58:36 +02001160 desc = &s->check_data[5];
1161 //Warning("protoerr: %s\n", desc);
1162 set_server_check_status(s, HCHK_STATUS_L7RSP, desc);
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001163 }
1164 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02001165 break;
1166
1167 case PR_O2_LDAP_CHK:
Gabor Lekenyb4c81e42010-09-29 18:17:05 +02001168 if (!done && s->check_data_len < 14)
1169 goto wait_more_data;
1170
1171 /* Check if the server speaks LDAP (ASN.1/BER)
1172 * http://en.wikipedia.org/wiki/Basic_Encoding_Rules
1173 * http://tools.ietf.org/html/rfc4511
1174 */
1175
1176 /* http://tools.ietf.org/html/rfc4511#section-4.1.1
1177 * LDAPMessage: 0x30: SEQUENCE
1178 */
1179 if ((s->check_data_len < 14) || (*(s->check_data) != '\x30')) {
1180 set_server_check_status(s, HCHK_STATUS_L7RSP, "Not LDAPv3 protocol");
1181 }
1182 else {
1183 /* size of LDAPMessage */
1184 msglen = (*(s->check_data + 1) & 0x80) ? (*(s->check_data + 1) & 0x7f) : 0;
1185
1186 /* http://tools.ietf.org/html/rfc4511#section-4.2.2
1187 * messageID: 0x02 0x01 0x01: INTEGER 1
1188 * protocolOp: 0x61: bindResponse
1189 */
1190 if ((msglen > 2) ||
1191 (memcmp(s->check_data + 2 + msglen, "\x02\x01\x01\x61", 4) != 0)) {
1192 set_server_check_status(s, HCHK_STATUS_L7RSP, "Not LDAPv3 protocol");
1193
1194 goto out_wakeup;
1195 }
1196
1197 /* size of bindResponse */
1198 msglen += (*(s->check_data + msglen + 6) & 0x80) ? (*(s->check_data + msglen + 6) & 0x7f) : 0;
1199
1200 /* http://tools.ietf.org/html/rfc4511#section-4.1.9
1201 * ldapResult: 0x0a 0x01: ENUMERATION
1202 */
1203 if ((msglen > 4) ||
1204 (memcmp(s->check_data + 7 + msglen, "\x0a\x01", 2) != 0)) {
1205 set_server_check_status(s, HCHK_STATUS_L7RSP, "Not LDAPv3 protocol");
1206
1207 goto out_wakeup;
1208 }
1209
1210 /* http://tools.ietf.org/html/rfc4511#section-4.1.9
1211 * resultCode
1212 */
1213 s->check_code = *(s->check_data + msglen + 9);
1214 if (s->check_code) {
1215 set_server_check_status(s, HCHK_STATUS_L7STS, "See RFC: http://tools.ietf.org/html/rfc4511#section-4.1.9");
1216 } else {
1217 set_server_check_status(s, HCHK_STATUS_L7OKD, "Success");
1218 }
1219 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02001220 break;
1221
1222 default:
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001223 /* other checks are valid if the connection succeeded anyway */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001224 set_server_check_status(s, HCHK_STATUS_L4OK, NULL);
Willy Tarreau1620ec32011-08-06 17:05:02 +02001225 break;
1226 } /* switch */
Willy Tarreau83749182007-04-15 20:56:27 +02001227
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001228 out_wakeup:
1229 if (s->result & SRV_CHK_ERROR)
Willy Tarreau505e34a2012-07-06 10:17:53 +02001230 s->check_conn->flags |= CO_FL_ERROR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001231
Nick Chalk57b1bf72010-03-16 15:50:46 +00001232 /* Reset the check buffer... */
1233 *s->check_data = '\0';
1234 s->check_data_len = 0;
1235
Willy Tarreau03938182010-03-17 21:52:07 +01001236 /* Close the connection... */
1237 shutdown(fd, SHUT_RDWR);
Willy Tarreau49b046d2012-08-09 12:11:58 +02001238 fd_stop_recv(fd);
Willy Tarreaufdccded2008-08-29 18:19:04 +02001239 task_wakeup(t, TASK_WOKEN_IO);
Willy Tarreaud6f087e2008-01-18 17:20:13 +01001240 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau3267d362012-08-17 23:53:56 +02001241 return;
Willy Tarreau03938182010-03-17 21:52:07 +01001242
1243 wait_more_data:
1244 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau3267d362012-08-17 23:53:56 +02001245 fd_poll_recv(fd);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001246}
1247
Willy Tarreau3267d362012-08-17 23:53:56 +02001248/* I/O call back for the health checks. Returns 0. */
Willy Tarreau20bea422012-07-06 12:00:49 +02001249static int check_iocb(int fd)
1250{
Willy Tarreau20bea422012-07-06 12:00:49 +02001251 int e;
1252
1253 if (!fdtab[fd].owner)
Willy Tarreau3267d362012-08-17 23:53:56 +02001254 return 0;
Willy Tarreau20bea422012-07-06 12:00:49 +02001255
1256 e = fdtab[fd].ev;
1257 if (e & (FD_POLL_IN | FD_POLL_HUP | FD_POLL_ERR))
Willy Tarreau3267d362012-08-17 23:53:56 +02001258 event_srv_chk_r(fd);
Willy Tarreau20bea422012-07-06 12:00:49 +02001259 if (e & (FD_POLL_OUT | FD_POLL_ERR))
Willy Tarreau3267d362012-08-17 23:53:56 +02001260 event_srv_chk_w(fd);
1261 return 0;
Willy Tarreau20bea422012-07-06 12:00:49 +02001262}
1263
Willy Tarreaubaaee002006-06-26 02:48:02 +02001264/*
Willy Tarreau2e993902011-10-31 11:53:20 +01001265 * updates the server's weight during a warmup stage. Once the final weight is
1266 * reached, the task automatically stops. Note that any server status change
1267 * must have updated s->last_change accordingly.
1268 */
1269static struct task *server_warmup(struct task *t)
1270{
1271 struct server *s = t->context;
1272
1273 /* by default, plan on stopping the task */
1274 t->expire = TICK_ETERNITY;
1275 if ((s->state & (SRV_RUNNING|SRV_WARMINGUP|SRV_MAINTAIN)) != (SRV_RUNNING|SRV_WARMINGUP))
1276 return t;
1277
1278 if (now.tv_sec < s->last_change || now.tv_sec >= s->last_change + s->slowstart) {
1279 /* go to full throttle if the slowstart interval is reached */
1280 s->state &= ~SRV_WARMINGUP;
1281 if (s->proxy->lbprm.algo & BE_LB_PROP_DYN)
1282 s->eweight = s->uweight * BE_WEIGHT_SCALE;
1283 if (s->proxy->lbprm.update_server_eweight)
1284 s->proxy->lbprm.update_server_eweight(s);
1285 }
1286 else if (s->proxy->lbprm.algo & BE_LB_PROP_DYN) {
1287 /* for dynamic algorithms, let's slowly update the weight */
1288 s->eweight = (BE_WEIGHT_SCALE * (now.tv_sec - s->last_change) +
1289 s->slowstart - 1) / s->slowstart;
1290 s->eweight *= s->uweight;
1291 if (s->proxy->lbprm.update_server_eweight)
1292 s->proxy->lbprm.update_server_eweight(s);
1293 }
1294 /* Note that static algorithms are already running at full throttle */
1295
1296 /* probably that we can refill this server with a bit more connections */
1297 check_for_pending(s);
1298
1299 /* get back there in 1 second or 1/20th of the slowstart interval,
1300 * whichever is greater, resulting in small 5% steps.
1301 */
1302 if (s->state & SRV_WARMINGUP)
1303 t->expire = tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20)));
1304 return t;
1305}
1306
1307/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001308 * manages a server health-check. Returns
1309 * the time the task accepts to wait, or TIME_ETERNITY for infinity.
1310 */
Simon Horman63a4a822012-03-19 07:24:41 +09001311static struct task *process_chk(struct task *t)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001312{
Willy Tarreaue3838802009-03-21 18:58:32 +01001313 int attempts = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001314 struct server *s = t->context;
David du Colombier6f5ccb12011-03-10 22:26:24 +01001315 struct sockaddr_storage sa;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001316 int fd;
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001317 int rv;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001318
Willy Tarreaubaaee002006-06-26 02:48:02 +02001319 new_chk:
Willy Tarreaue3838802009-03-21 18:58:32 +01001320 if (attempts++ > 0) {
1321 /* we always fail to create a server, let's stop insisting... */
1322 while (tick_is_expired(t->expire, now_ms))
1323 t->expire = tick_add(t->expire, MS_TO_TICKS(s->inter));
1324 return t;
1325 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001326 fd = s->curfd;
1327 if (fd < 0) { /* no check currently running */
Willy Tarreau26c25062009-03-08 09:38:41 +01001328 if (!tick_is_expired(t->expire, now_ms)) /* woke up too early */
1329 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001330
1331 /* we don't send any health-checks when the proxy is stopped or when
1332 * the server should not be checked.
1333 */
Cyril Bontécd19e512010-01-31 22:34:03 +01001334 if (!(s->state & SRV_CHECKED) || s->proxy->state == PR_STSTOPPED || (s->state & SRV_MAINTAIN)) {
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001335 while (tick_is_expired(t->expire, now_ms))
1336 t->expire = tick_add(t->expire, MS_TO_TICKS(s->inter));
Willy Tarreau26c25062009-03-08 09:38:41 +01001337 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001338 }
1339
1340 /* we'll initiate a new check */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001341 set_server_check_status(s, HCHK_STATUS_START, NULL);
David du Colombier6f5ccb12011-03-10 22:26:24 +01001342 if ((fd = socket(s->addr.ss_family, SOCK_STREAM, IPPROTO_TCP)) != -1) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001343 if ((fd < global.maxsock) &&
1344 (fcntl(fd, F_SETFL, O_NONBLOCK) != -1) &&
1345 (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one)) != -1)) {
1346 //fprintf(stderr, "process_chk: 3\n");
1347
Willy Tarreau9edd1612007-10-18 18:07:48 +02001348 if (s->proxy->options & PR_O_TCP_NOLING) {
1349 /* We don't want to useless data */
1350 setsockopt(fd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
1351 }
David du Colombier6f5ccb12011-03-10 22:26:24 +01001352
1353 if (is_addr(&s->check_addr))
Willy Tarreau0f03c6f2007-03-25 20:46:19 +02001354 /* we'll connect to the check addr specified on the server */
Willy Tarreau2ea3abb2007-03-25 16:45:16 +02001355 sa = s->check_addr;
Willy Tarreau2ea3abb2007-03-25 16:45:16 +02001356 else
Willy Tarreau0f03c6f2007-03-25 20:46:19 +02001357 /* we'll connect to the addr on the server */
Willy Tarreau2ea3abb2007-03-25 16:45:16 +02001358 sa = s->addr;
Willy Tarreau0f03c6f2007-03-25 20:46:19 +02001359
Willy Tarreau48da04a2011-08-27 11:51:36 +02001360 set_host_port(&sa, s->check_port);
1361
Willy Tarreaubaaee002006-06-26 02:48:02 +02001362 /* allow specific binding :
1363 * - server-specific at first
1364 * - proxy-specific next
1365 */
1366 if (s->state & SRV_BIND_SRC) {
David du Colombier6f5ccb12011-03-10 22:26:24 +01001367 struct sockaddr_storage *remote = NULL;
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001368 int ret, flags = 0;
Willy Tarreau163c5322006-11-14 16:18:41 +01001369
Willy Tarreaucf1d5722008-02-14 20:28:18 +01001370#if defined(CONFIG_HAP_CTTPROXY) || defined(CONFIG_HAP_LINUX_TPROXY)
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001371 if ((s->state & SRV_TPROXY_MASK) == SRV_TPROXY_ADDR) {
David du Colombier6f5ccb12011-03-10 22:26:24 +01001372 remote = &s->tproxy_addr;
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001373 flags = 3;
1374 }
Willy Tarreaucf1d5722008-02-14 20:28:18 +01001375#endif
Willy Tarreauc76721d2009-02-04 20:20:58 +01001376#ifdef SO_BINDTODEVICE
1377 /* Note: this might fail if not CAP_NET_RAW */
1378 if (s->iface_name)
1379 setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
Willy Tarreau604e8302009-03-06 00:48:23 +01001380 s->iface_name, s->iface_len + 1);
Willy Tarreauc76721d2009-02-04 20:20:58 +01001381#endif
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001382 if (s->sport_range) {
1383 int bind_attempts = 10; /* should be more than enough to find a spare port */
David du Colombier6f5ccb12011-03-10 22:26:24 +01001384 struct sockaddr_storage src;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001385
1386 ret = 1;
1387 src = s->source_addr;
1388
1389 do {
1390 /* note: in case of retry, we may have to release a previously
1391 * allocated port, hence this loop's construct.
1392 */
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001393 port_range_release_port(fdinfo[fd].port_range, fdinfo[fd].local_port);
1394 fdinfo[fd].port_range = NULL;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001395
1396 if (!bind_attempts)
1397 break;
1398 bind_attempts--;
1399
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001400 fdinfo[fd].local_port = port_range_alloc_port(s->sport_range);
1401 if (!fdinfo[fd].local_port)
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001402 break;
1403
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001404 fdinfo[fd].port_range = s->sport_range;
Willy Tarreau86ad42c2011-08-27 12:29:07 +02001405 set_host_port(&src, fdinfo[fd].local_port);
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001406
David du Colombier6f5ccb12011-03-10 22:26:24 +01001407 ret = tcp_bind_socket(fd, flags, &src, remote);
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001408 } while (ret != 0); /* binding NOK */
1409 }
1410 else {
David du Colombier6f5ccb12011-03-10 22:26:24 +01001411 ret = tcp_bind_socket(fd, flags, &s->source_addr, remote);
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001412 }
1413
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001414 if (ret) {
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001415 set_server_check_status(s, HCHK_STATUS_SOCKERR, NULL);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001416 switch (ret) {
1417 case 1:
1418 Alert("Cannot bind to source address before connect() for server %s/%s. Aborting.\n",
1419 s->proxy->id, s->id);
1420 break;
1421 case 2:
Willy Tarreau163c5322006-11-14 16:18:41 +01001422 Alert("Cannot bind to tproxy source address before connect() for server %s/%s. Aborting.\n",
1423 s->proxy->id, s->id);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001424 break;
Willy Tarreau163c5322006-11-14 16:18:41 +01001425 }
1426 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001427 }
1428 else if (s->proxy->options & PR_O_BIND_SRC) {
David du Colombier6f5ccb12011-03-10 22:26:24 +01001429 struct sockaddr_storage *remote = NULL;
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001430 int ret, flags = 0;
1431
Willy Tarreaucf1d5722008-02-14 20:28:18 +01001432#if defined(CONFIG_HAP_CTTPROXY) || defined(CONFIG_HAP_LINUX_TPROXY)
Willy Tarreau163c5322006-11-14 16:18:41 +01001433 if ((s->proxy->options & PR_O_TPXY_MASK) == PR_O_TPXY_ADDR) {
David du Colombier6f5ccb12011-03-10 22:26:24 +01001434 remote = &s->proxy->tproxy_addr;
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001435 flags = 3;
1436 }
Willy Tarreaucf1d5722008-02-14 20:28:18 +01001437#endif
Willy Tarreaud53f96b2009-02-04 18:46:54 +01001438#ifdef SO_BINDTODEVICE
1439 /* Note: this might fail if not CAP_NET_RAW */
1440 if (s->proxy->iface_name)
1441 setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
Willy Tarreau604e8302009-03-06 00:48:23 +01001442 s->proxy->iface_name, s->proxy->iface_len + 1);
Willy Tarreaud53f96b2009-02-04 18:46:54 +01001443#endif
David du Colombier6f5ccb12011-03-10 22:26:24 +01001444 ret = tcp_bind_socket(fd, flags, &s->proxy->source_addr, remote);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001445 if (ret) {
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001446 set_server_check_status(s, HCHK_STATUS_SOCKERR, NULL);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001447 switch (ret) {
1448 case 1:
1449 Alert("Cannot bind to source address before connect() for %s '%s'. Aborting.\n",
1450 proxy_type_str(s->proxy), s->proxy->id);
1451 break;
1452 case 2:
Willy Tarreau2b5652f2006-12-31 17:46:05 +01001453 Alert("Cannot bind to tproxy source address before connect() for %s '%s'. Aborting.\n",
1454 proxy_type_str(s->proxy), s->proxy->id);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001455 break;
Willy Tarreau163c5322006-11-14 16:18:41 +01001456 }
1457 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001458 }
1459
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001460 if (s->result == SRV_CHK_UNKNOWN) {
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +04001461#if defined(TCP_QUICKACK)
Willy Tarreau1274bc42009-07-15 07:16:31 +02001462 /* disabling tcp quick ack now allows
1463 * the request to leave the machine with
1464 * the first ACK.
1465 */
1466 if (s->proxy->options2 & PR_O2_SMARTCON)
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +04001467 setsockopt(fd, IPPROTO_TCP, TCP_QUICKACK, (char *) &zero, sizeof(zero));
Willy Tarreau1274bc42009-07-15 07:16:31 +02001468#endif
Willy Tarreau1b4b7ce2011-04-05 16:56:50 +02001469 if ((connect(fd, (struct sockaddr *)&sa, get_addr_len(&sa)) != -1) || (errno == EINPROGRESS)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001470 /* OK, connection in progress or established */
1471
1472 //fprintf(stderr, "process_chk: 4\n");
1473
1474 s->curfd = fd; /* that's how we know a test is in progress ;-) */
Willy Tarreau505e34a2012-07-06 10:17:53 +02001475 s->check_conn->flags = CO_FL_WAIT_L4_CONN; /* TCP connection pending */
Willy Tarreau7a966482007-04-15 10:58:02 +02001476 fd_insert(fd);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001477 fdtab[fd].owner = t;
Willy Tarreau20bea422012-07-06 12:00:49 +02001478 fdtab[fd].iocb = &check_iocb;
Willy Tarreau49b046d2012-08-09 12:11:58 +02001479 fd_want_send(fd); /* for connect status */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001480#ifdef DEBUG_FULL
Willy Tarreauf161a342007-04-08 16:59:42 +02001481 assert (!EV_FD_ISSET(fd, DIR_RD));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001482#endif
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001483 //fprintf(stderr, "process_chk: 4+, %lu\n", __tv_to_ms(&s->proxy->timeout.connect));
1484 /* we allow up to min(inter, timeout.connect) for a connection
1485 * to establish but only when timeout.check is set
1486 * as it may be to short for a full check otherwise
1487 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001488 t->expire = tick_add(now_ms, MS_TO_TICKS(s->inter));
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001489
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001490 if (s->proxy->timeout.check && s->proxy->timeout.connect) {
1491 int t_con = tick_add(now_ms, s->proxy->timeout.connect);
1492 t->expire = tick_first(t->expire, t_con);
Willy Tarreau60548192008-02-17 11:34:10 +01001493 }
Willy Tarreau26c25062009-03-08 09:38:41 +01001494 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001495 }
1496 else if (errno != EALREADY && errno != EISCONN && errno != EAGAIN) {
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +02001497 /* a real error */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001498
1499 switch (errno) {
1500 /* FIXME: is it possible to get ECONNREFUSED/ENETUNREACH with O_NONBLOCK? */
1501 case ECONNREFUSED:
1502 case ENETUNREACH:
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001503 set_server_check_status(s, HCHK_STATUS_L4CON, strerror(errno));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001504 break;
1505
1506 default:
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001507 set_server_check_status(s, HCHK_STATUS_SOCKERR, strerror(errno));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001508 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001509 }
1510 }
1511 }
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001512 port_range_release_port(fdinfo[fd].port_range, fdinfo[fd].local_port);
1513 fdinfo[fd].port_range = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001514 close(fd); /* socket creation error */
1515 }
Willy Tarreaud11ad782011-03-09 20:38:33 +01001516 else
1517 set_server_check_status(s, HCHK_STATUS_SOCKERR, strerror(errno));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001518
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001519 if (s->result == SRV_CHK_UNKNOWN) { /* nothing done */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001520 //fprintf(stderr, "process_chk: 6\n");
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001521 while (tick_is_expired(t->expire, now_ms))
1522 t->expire = tick_add(t->expire, MS_TO_TICKS(s->inter));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001523 goto new_chk; /* may be we should initialize a new check */
1524 }
1525
1526 /* here, we have seen a failure */
1527 if (s->health > s->rise) {
1528 s->health--; /* still good */
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +02001529 s->counters.failed_checks++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001530 }
1531 else
1532 set_server_down(s);
1533
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001534 //fprintf(stderr, "process_chk: 7, %lu\n", __tv_to_ms(&s->proxy->timeout.connect));
1535 /* we allow up to min(inter, timeout.connect) for a connection
1536 * to establish but only when timeout.check is set
1537 * as it may be to short for a full check otherwise
1538 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001539 while (tick_is_expired(t->expire, now_ms)) {
1540 int t_con;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001541
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001542 t_con = tick_add(t->expire, s->proxy->timeout.connect);
1543 t->expire = tick_add(t->expire, MS_TO_TICKS(s->inter));
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001544
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001545 if (s->proxy->timeout.check)
1546 t->expire = tick_first(t->expire, t_con);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001547 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001548 goto new_chk;
1549 }
1550 else {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001551 /* there was a test running */
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001552 if ((s->result & (SRV_CHK_ERROR|SRV_CHK_RUNNING)) == SRV_CHK_RUNNING) { /* good server detected */
Willy Tarreau48494c02007-11-30 10:41:39 +01001553 /* we may have to add/remove this server from the LB group */
1554 if ((s->state & SRV_RUNNING) && (s->proxy->options & PR_O_DISABLE404)) {
1555 if ((s->state & SRV_GOINGDOWN) &&
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +01001556 ((s->result & (SRV_CHK_RUNNING|SRV_CHK_DISABLE)) == SRV_CHK_RUNNING))
1557 set_server_enabled(s);
Willy Tarreau48494c02007-11-30 10:41:39 +01001558 else if (!(s->state & SRV_GOINGDOWN) &&
1559 ((s->result & (SRV_CHK_RUNNING | SRV_CHK_DISABLE)) ==
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +01001560 (SRV_CHK_RUNNING | SRV_CHK_DISABLE)))
1561 set_server_disabled(s);
Willy Tarreau48494c02007-11-30 10:41:39 +01001562 }
1563
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001564 if (s->health < s->rise + s->fall - 1) {
1565 s->health++; /* was bad, stays for a while */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001566
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +01001567 set_server_up(s);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001568 }
1569 s->curfd = -1; /* no check running anymore */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001570 fd_delete(fd);
Willy Tarreau44ec0f02007-10-14 23:47:04 +02001571
1572 rv = 0;
1573 if (global.spread_checks > 0) {
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001574 rv = srv_getinter(s) * global.spread_checks / 100;
Willy Tarreau44ec0f02007-10-14 23:47:04 +02001575 rv -= (int) (2 * rv * (rand() / (RAND_MAX + 1.0)));
Willy Tarreau44ec0f02007-10-14 23:47:04 +02001576 }
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001577 t->expire = tick_add(now_ms, MS_TO_TICKS(srv_getinter(s) + rv));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001578 goto new_chk;
1579 }
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001580 else if ((s->result & SRV_CHK_ERROR) || tick_is_expired(t->expire, now_ms)) {
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001581 if (!(s->result & SRV_CHK_ERROR)) {
1582 if (!EV_FD_ISSET(fd, DIR_RD)) {
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001583 set_server_check_status(s, HCHK_STATUS_L4TOUT, NULL);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001584 } else {
Willy Tarreau1620ec32011-08-06 17:05:02 +02001585 if ((s->proxy->options2 & PR_O2_CHK_ANY) == PR_O2_SSL3_CHK)
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001586 set_server_check_status(s, HCHK_STATUS_L6TOUT, NULL);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001587 else /* HTTP, SMTP */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001588 set_server_check_status(s, HCHK_STATUS_L7TOUT, NULL);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001589 }
1590 }
1591
Willy Tarreaubaaee002006-06-26 02:48:02 +02001592 /* failure or timeout detected */
1593 if (s->health > s->rise) {
1594 s->health--; /* still good */
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +02001595 s->counters.failed_checks++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001596 }
1597 else
1598 set_server_down(s);
1599 s->curfd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001600 fd_delete(fd);
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001601
1602 rv = 0;
1603 if (global.spread_checks > 0) {
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001604 rv = srv_getinter(s) * global.spread_checks / 100;
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001605 rv -= (int) (2 * rv * (rand() / (RAND_MAX + 1.0)));
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001606 }
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001607 t->expire = tick_add(now_ms, MS_TO_TICKS(srv_getinter(s) + rv));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001608 goto new_chk;
1609 }
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001610 /* if result is unknown and there's no timeout, we have to wait again */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001611 }
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001612 s->result = SRV_CHK_UNKNOWN;
Willy Tarreau26c25062009-03-08 09:38:41 +01001613 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001614}
1615
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001616/*
1617 * Start health-check.
1618 * Returns 0 if OK, -1 if error, and prints the error in this case.
1619 */
1620int start_checks() {
1621
1622 struct proxy *px;
1623 struct server *s;
1624 struct task *t;
1625 int nbchk=0, mininter=0, srvpos=0;
1626
Willy Tarreau2c43a1e2007-10-14 23:05:39 +02001627 /* 1- count the checkers to run simultaneously.
1628 * We also determine the minimum interval among all of those which
1629 * have an interval larger than SRV_CHK_INTER_THRES. This interval
1630 * will be used to spread their start-up date. Those which have
Jamie Gloudon801a0a32012-08-25 00:18:33 -04001631 * a shorter interval will start independently and will not dictate
Willy Tarreau2c43a1e2007-10-14 23:05:39 +02001632 * too short an interval for all others.
1633 */
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001634 for (px = proxy; px; px = px->next) {
1635 for (s = px->srv; s; s = s->next) {
1636 if (!(s->state & SRV_CHECKED))
1637 continue;
1638
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001639 if ((srv_getinter(s) >= SRV_CHK_INTER_THRES) &&
1640 (!mininter || mininter > srv_getinter(s)))
1641 mininter = srv_getinter(s);
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001642
1643 nbchk++;
1644 }
1645 }
1646
1647 if (!nbchk)
1648 return 0;
1649
1650 srand((unsigned)time(NULL));
1651
1652 /*
1653 * 2- start them as far as possible from each others. For this, we will
1654 * start them after their interval set to the min interval divided by
1655 * the number of servers, weighted by the server's position in the list.
1656 */
1657 for (px = proxy; px; px = px->next) {
1658 for (s = px->srv; s; s = s->next) {
Willy Tarreau2e993902011-10-31 11:53:20 +01001659 if (s->slowstart) {
1660 if ((t = task_new()) == NULL) {
1661 Alert("Starting [%s:%s] check: out of memory.\n", px->id, s->id);
1662 return -1;
1663 }
1664 /* We need a warmup task that will be called when the server
1665 * state switches from down to up.
1666 */
1667 s->warmup = t;
1668 t->process = server_warmup;
1669 t->context = s;
1670 t->expire = TICK_ETERNITY;
1671 }
1672
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001673 if (!(s->state & SRV_CHECKED))
1674 continue;
1675
Willy Tarreau2e993902011-10-31 11:53:20 +01001676 /* one task for the checks */
Willy Tarreaua4613182009-03-21 18:13:21 +01001677 if ((t = task_new()) == NULL) {
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001678 Alert("Starting [%s:%s] check: out of memory.\n", px->id, s->id);
1679 return -1;
1680 }
1681
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02001682 s->check = t;
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001683 t->process = process_chk;
1684 t->context = s;
1685
1686 /* check this every ms */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001687 t->expire = tick_add(now_ms,
1688 MS_TO_TICKS(((mininter && mininter >= srv_getinter(s)) ?
1689 mininter : srv_getinter(s)) * srvpos / nbchk));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001690 s->check_start = now;
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001691 task_queue(t);
1692
1693 srvpos++;
1694 }
1695 }
1696 return 0;
1697}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001698
1699/*
Willy Tarreaubd741542010-03-16 18:46:54 +01001700 * Perform content verification check on data in s->check_data buffer.
1701 * The buffer MUST be terminated by a null byte before calling this function.
1702 * Sets server status appropriately. The caller is responsible for ensuring
1703 * that the buffer contains at least 13 characters. If <done> is zero, we may
1704 * return 0 to indicate that data is required to decide of a match.
1705 */
1706static int httpchk_expect(struct server *s, int done)
1707{
1708 static char status_msg[] = "HTTP status check returned code <000>";
1709 char status_code[] = "000";
1710 char *contentptr;
1711 int crlf;
1712 int ret;
1713
1714 switch (s->proxy->options2 & PR_O2_EXP_TYPE) {
1715 case PR_O2_EXP_STS:
1716 case PR_O2_EXP_RSTS:
1717 memcpy(status_code, s->check_data + 9, 3);
1718 memcpy(status_msg + strlen(status_msg) - 4, s->check_data + 9, 3);
1719
1720 if ((s->proxy->options2 & PR_O2_EXP_TYPE) == PR_O2_EXP_STS)
1721 ret = strncmp(s->proxy->expect_str, status_code, 3) == 0;
1722 else
1723 ret = regexec(s->proxy->expect_regex, status_code, MAX_MATCH, pmatch, 0) == 0;
1724
1725 /* we necessarily have the response, so there are no partial failures */
1726 if (s->proxy->options2 & PR_O2_EXP_INV)
1727 ret = !ret;
1728
1729 set_server_check_status(s, ret ? HCHK_STATUS_L7OKD : HCHK_STATUS_L7STS, status_msg);
1730 break;
1731
1732 case PR_O2_EXP_STR:
1733 case PR_O2_EXP_RSTR:
1734 /* very simple response parser: ignore CR and only count consecutive LFs,
1735 * stop with contentptr pointing to first char after the double CRLF or
1736 * to '\0' if crlf < 2.
1737 */
1738 crlf = 0;
1739 for (contentptr = s->check_data; *contentptr; contentptr++) {
1740 if (crlf >= 2)
1741 break;
1742 if (*contentptr == '\r')
1743 continue;
1744 else if (*contentptr == '\n')
1745 crlf++;
1746 else
1747 crlf = 0;
1748 }
1749
1750 /* Check that response contains a body... */
1751 if (crlf < 2) {
1752 if (!done)
1753 return 0;
1754
1755 set_server_check_status(s, HCHK_STATUS_L7RSP,
1756 "HTTP content check could not find a response body");
1757 return 1;
1758 }
1759
1760 /* Check that response body is not empty... */
1761 if (*contentptr == '\0') {
Willy Tarreaua164fb52011-04-13 09:32:41 +02001762 if (!done)
1763 return 0;
1764
Willy Tarreaubd741542010-03-16 18:46:54 +01001765 set_server_check_status(s, HCHK_STATUS_L7RSP,
1766 "HTTP content check found empty response body");
1767 return 1;
1768 }
1769
1770 /* Check the response content against the supplied string
1771 * or regex... */
1772 if ((s->proxy->options2 & PR_O2_EXP_TYPE) == PR_O2_EXP_STR)
1773 ret = strstr(contentptr, s->proxy->expect_str) != NULL;
1774 else
1775 ret = regexec(s->proxy->expect_regex, contentptr, MAX_MATCH, pmatch, 0) == 0;
1776
1777 /* if we don't match, we may need to wait more */
1778 if (!ret && !done)
1779 return 0;
1780
1781 if (ret) {
1782 /* content matched */
1783 if (s->proxy->options2 & PR_O2_EXP_INV)
1784 set_server_check_status(s, HCHK_STATUS_L7RSP,
1785 "HTTP check matched unwanted content");
1786 else
1787 set_server_check_status(s, HCHK_STATUS_L7OKD,
1788 "HTTP content check matched");
1789 }
1790 else {
1791 if (s->proxy->options2 & PR_O2_EXP_INV)
1792 set_server_check_status(s, HCHK_STATUS_L7OKD,
1793 "HTTP check did not match unwanted content");
1794 else
1795 set_server_check_status(s, HCHK_STATUS_L7RSP,
1796 "HTTP content check did not match");
1797 }
1798 break;
1799 }
1800 return 1;
1801}
1802
1803/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001804 * Local variables:
1805 * c-indent-level: 8
1806 * c-basic-offset: 8
1807 * End:
1808 */