blob: 502d905867cdf0481f631ebb45475a278e2104b8 [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 Tarreau2dd0d472006-06-29 17:53:05 +020029#include <common/compat.h>
30#include <common/config.h>
31#include <common/mini-clist.h>
Willy Tarreau83749182007-04-15 20:56:27 +020032#include <common/standard.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020033#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034
35#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036
37#include <proto/backend.h>
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020038#include <proto/checks.h>
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +010039#include <proto/buffers.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>
48#include <proto/task.h>
49
Willy Tarreaubd741542010-03-16 18:46:54 +010050static int httpchk_expect(struct server *s, int done);
51
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020052const struct check_status check_statuses[HCHK_STATUS_SIZE] = {
53 [HCHK_STATUS_UNKNOWN] = { SRV_CHK_UNKNOWN, "UNK", "Unknown" },
54 [HCHK_STATUS_INI] = { SRV_CHK_UNKNOWN, "INI", "Initializing" },
55 [HCHK_STATUS_START] = { /* SPECIAL STATUS*/ },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020056
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +010057 [HCHK_STATUS_HANA] = { SRV_CHK_ERROR, "HANA", "Health analyze" },
58
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020059 [HCHK_STATUS_SOCKERR] = { SRV_CHK_ERROR, "SOCKERR", "Socket error" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020060
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020061 [HCHK_STATUS_L4OK] = { SRV_CHK_RUNNING, "L4OK", "Layer4 check passed" },
62 [HCHK_STATUS_L4TOUT] = { SRV_CHK_ERROR, "L4TOUT", "Layer4 timeout" },
63 [HCHK_STATUS_L4CON] = { SRV_CHK_ERROR, "L4CON", "Layer4 connection problem" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020064
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020065 [HCHK_STATUS_L6OK] = { SRV_CHK_RUNNING, "L6OK", "Layer6 check passed" },
66 [HCHK_STATUS_L6TOUT] = { SRV_CHK_ERROR, "L6TOUT", "Layer6 timeout" },
67 [HCHK_STATUS_L6RSP] = { SRV_CHK_ERROR, "L6RSP", "Layer6 invalid response" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020068
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020069 [HCHK_STATUS_L7TOUT] = { SRV_CHK_ERROR, "L7TOUT", "Layer7 timeout" },
70 [HCHK_STATUS_L7RSP] = { SRV_CHK_ERROR, "L7RSP", "Layer7 invalid response" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020071
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020072 [HCHK_STATUS_L57DATA] = { /* DUMMY STATUS */ },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020073
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020074 [HCHK_STATUS_L7OKD] = { SRV_CHK_RUNNING, "L7OK", "Layer7 check passed" },
75 [HCHK_STATUS_L7OKCD] = { SRV_CHK_RUNNING | SRV_CHK_DISABLE, "L7OKC", "Layer7 check conditionally passed" },
76 [HCHK_STATUS_L7STS] = { SRV_CHK_ERROR, "L7STS", "Layer7 wrong status" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020077};
78
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +010079const struct analyze_status analyze_statuses[HANA_STATUS_SIZE] = { /* 0: ignore, 1: error, 2: OK */
80 [HANA_STATUS_UNKNOWN] = { "Unknown", { 0, 0 }},
81
82 [HANA_STATUS_L4_OK] = { "L4 successful connection", { 2, 0 }},
83 [HANA_STATUS_L4_ERR] = { "L4 unsuccessful connection", { 1, 1 }},
84
85 [HANA_STATUS_HTTP_OK] = { "Correct http response", { 0, 2 }},
86 [HANA_STATUS_HTTP_STS] = { "Wrong http response", { 0, 1 }},
87 [HANA_STATUS_HTTP_HDRRSP] = { "Invalid http response (headers)", { 0, 1 }},
88 [HANA_STATUS_HTTP_RSP] = { "Invalid http response", { 0, 1 }},
89
90 [HANA_STATUS_HTTP_READ_ERROR] = { "Read error (http)", { 0, 1 }},
91 [HANA_STATUS_HTTP_READ_TIMEOUT] = { "Read timeout (http)", { 0, 1 }},
92 [HANA_STATUS_HTTP_BROKEN_PIPE] = { "Close from server (http)", { 0, 1 }},
93};
94
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020095/*
96 * Convert check_status code to description
97 */
98const char *get_check_status_description(short check_status) {
99
100 const char *desc;
101
102 if (check_status < HCHK_STATUS_SIZE)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200103 desc = check_statuses[check_status].desc;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200104 else
105 desc = NULL;
106
107 if (desc && *desc)
108 return desc;
109 else
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200110 return check_statuses[HCHK_STATUS_UNKNOWN].desc;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200111}
112
113/*
114 * Convert check_status code to short info
115 */
116const char *get_check_status_info(short check_status) {
117
118 const char *info;
119
120 if (check_status < HCHK_STATUS_SIZE)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200121 info = check_statuses[check_status].info;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200122 else
123 info = NULL;
124
125 if (info && *info)
126 return info;
127 else
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200128 return check_statuses[HCHK_STATUS_UNKNOWN].info;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200129}
130
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100131const char *get_analyze_status(short analyze_status) {
132
133 const char *desc;
134
135 if (analyze_status < HANA_STATUS_SIZE)
136 desc = analyze_statuses[analyze_status].desc;
137 else
138 desc = NULL;
139
140 if (desc && *desc)
141 return desc;
142 else
143 return analyze_statuses[HANA_STATUS_UNKNOWN].desc;
144}
145
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200146#define SSP_O_HCHK 0x0002
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200147
148static void server_status_printf(struct chunk *msg, struct server *s, unsigned options, int xferred) {
149
Krzysztof Piotr Oledzki5f5b7d22010-01-11 11:13:39 +0100150 if (s->tracked)
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200151 chunk_printf(msg, " via %s/%s",
152 s->tracked->proxy->id, s->tracked->id);
153
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200154 if (options & SSP_O_HCHK) {
155 chunk_printf(msg, ", reason: %s", get_check_status_description(s->check_status));
156
157 if (s->check_status >= HCHK_STATUS_L57DATA)
158 chunk_printf(msg, ", code: %d", s->check_code);
159
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200160 if (*s->check_desc) {
161 struct chunk src;
162
163 chunk_printf(msg, ", info: \"");
164
165 chunk_initlen(&src, s->check_desc, 0, strlen(s->check_desc));
166 chunk_asciiencode(msg, &src, '"');
167
168 chunk_printf(msg, "\"");
169 }
170
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100171 if (s->check_duration >= 0)
172 chunk_printf(msg, ", check duration: %ldms", s->check_duration);
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200173 }
174
Krzysztof Piotr Oledzki3bb05712010-09-27 13:10:50 +0200175 if (xferred >= 0) {
Krzysztof Piotr Oledzkib16a6072010-01-10 21:12:58 +0100176 if (!(s->state & SRV_RUNNING))
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200177 chunk_printf(msg, ". %d active and %d backup servers left.%s"
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100178 " %d sessions active, %d requeued, %d remaining in queue",
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200179 s->proxy->srv_act, s->proxy->srv_bck,
180 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
181 s->cur_sess, xferred, s->nbpend);
182 else
183 chunk_printf(msg, ". %d active and %d backup servers online.%s"
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100184 " %d sessions requeued, %d total in queue",
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200185 s->proxy->srv_act, s->proxy->srv_bck,
186 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
187 xferred, s->nbpend);
188 }
189}
190
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200191/*
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200192 * Set s->check_status, update s->check_duration and fill s->result with
193 * an adequate SRV_CHK_* value.
194 *
195 * Show information in logs about failed health check if server is UP
196 * or succeeded health checks if server is DOWN.
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200197 */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200198static void set_server_check_status(struct server *s, short status, char *desc) {
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200199
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200200 struct chunk msg;
201
202 if (status == HCHK_STATUS_START) {
203 s->result = SRV_CHK_UNKNOWN; /* no result yet */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200204 s->check_desc[0] = '\0';
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200205 s->check_start = now;
206 return;
207 }
208
209 if (!s->check_status)
210 return;
211
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200212 if (desc && *desc) {
213 strncpy(s->check_desc, desc, HCHK_DESC_LEN-1);
214 s->check_desc[HCHK_DESC_LEN-1] = '\0';
215 } else
216 s->check_desc[0] = '\0';
217
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200218 s->check_status = status;
219 if (check_statuses[status].result)
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100220 s->result = check_statuses[status].result;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200221
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100222 if (status == HCHK_STATUS_HANA)
223 s->check_duration = -1;
224 else if (!tv_iszero(&s->check_start)) {
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200225 /* set_server_check_status() may be called more than once */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200226 s->check_duration = tv_ms_elapsed(&s->check_start, &now);
227 tv_zero(&s->check_start);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200228 }
229
230 if (s->proxy->options2 & PR_O2_LOGHCHKS &&
231 (((s->health != 0) && (s->result & SRV_CHK_ERROR)) ||
232 ((s->health != s->rise + s->fall - 1) && (s->result & SRV_CHK_RUNNING)) ||
233 ((s->state & SRV_GOINGDOWN) && !(s->result & SRV_CHK_DISABLE)) ||
234 (!(s->state & SRV_GOINGDOWN) && (s->result & SRV_CHK_DISABLE)))) {
235
236 int health, rise, fall, state;
237
238 chunk_init(&msg, trash, sizeof(trash));
239
240 /* FIXME begin: calculate local version of the health/rise/fall/state */
241 health = s->health;
242 rise = s->rise;
243 fall = s->fall;
244 state = s->state;
245
246 if (s->result & SRV_CHK_ERROR) {
247 if (health > rise) {
248 health--; /* still good */
249 } else {
250 if (health == rise)
251 state &= ~(SRV_RUNNING | SRV_GOINGDOWN);
252
253 health = 0;
254 }
255 }
256
257 if (s->result & SRV_CHK_RUNNING) {
258 if (health < rise + fall - 1) {
259 health++; /* was bad, stays for a while */
260
261 if (health == rise)
262 state |= SRV_RUNNING;
263
264 if (health >= rise)
265 health = rise + fall - 1; /* OK now */
266 }
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100267
268 /* clear consecutive_errors if observing is enabled */
269 if (s->onerror)
270 s->consecutive_errors = 0;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200271 }
272 /* FIXME end: calculate local version of the health/rise/fall/state */
273
274 chunk_printf(&msg,
275 "Health check for %sserver %s/%s %s%s",
276 s->state & SRV_BACKUP ? "backup " : "",
277 s->proxy->id, s->id,
278 (s->result & SRV_CHK_DISABLE)?"conditionally ":"",
279 (s->result & SRV_CHK_RUNNING)?"succeeded":"failed");
280
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200281 server_status_printf(&msg, s, SSP_O_HCHK, -1);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200282
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100283 chunk_printf(&msg, ", status: %d/%d %s",
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200284 (state & SRV_RUNNING) ? (health - rise + 1) : (health),
285 (state & SRV_RUNNING) ? (fall) : (rise),
286 (state & SRV_RUNNING)?"UP":"DOWN");
287
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100288 Warning("%s.\n", trash);
289 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200290 }
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200291}
292
Willy Tarreau48494c02007-11-30 10:41:39 +0100293/* sends a log message when a backend goes down, and also sets last
294 * change date.
295 */
296static void set_backend_down(struct proxy *be)
297{
298 be->last_change = now.tv_sec;
299 be->down_trans++;
300
301 Alert("%s '%s' has no server available!\n", proxy_type_str(be), be->id);
302 send_log(be, LOG_EMERG, "%s %s has no server available!\n", proxy_type_str(be), be->id);
303}
304
305/* Redistribute pending connections when a server goes down. The number of
306 * connections redistributed is returned.
307 */
308static int redistribute_pending(struct server *s)
309{
310 struct pendconn *pc, *pc_bck, *pc_end;
311 int xferred = 0;
312
313 FOREACH_ITEM_SAFE(pc, pc_bck, &s->pendconns, pc_end, struct pendconn *, list) {
314 struct session *sess = pc->sess;
Willy Tarreau4de91492010-01-22 19:10:05 +0100315 if ((sess->be->options & (PR_O_REDISP|PR_O_PERSIST)) == PR_O_REDISP &&
316 !(sess->flags & SN_FORCE_PRST)) {
Willy Tarreau48494c02007-11-30 10:41:39 +0100317 /* The REDISP option was specified. We will ignore
318 * cookie and force to balance or use the dispatcher.
319 */
Krzysztof Piotr Oledzki25b501a2008-01-06 16:36:16 +0100320
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100321 /* it's left to the dispatcher to choose a server */
Willy Tarreau48494c02007-11-30 10:41:39 +0100322 sess->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
Krzysztof Piotr Oledzki25b501a2008-01-06 16:36:16 +0100323
Willy Tarreau48494c02007-11-30 10:41:39 +0100324 pendconn_free(pc);
Willy Tarreaufdccded2008-08-29 18:19:04 +0200325 task_wakeup(sess->task, TASK_WOKEN_RES);
Willy Tarreau48494c02007-11-30 10:41:39 +0100326 xferred++;
327 }
328 }
329 return xferred;
330}
331
332/* Check for pending connections at the backend, and assign some of them to
333 * the server coming up. The server's weight is checked before being assigned
334 * connections it may not be able to handle. The total number of transferred
335 * connections is returned.
336 */
337static int check_for_pending(struct server *s)
338{
339 int xferred;
340
341 if (!s->eweight)
342 return 0;
343
344 for (xferred = 0; !s->maxconn || xferred < srv_dynamic_maxconn(s); xferred++) {
345 struct session *sess;
346 struct pendconn *p;
347
348 p = pendconn_from_px(s->proxy);
349 if (!p)
350 break;
351 p->sess->srv = s;
352 sess = p->sess;
353 pendconn_free(p);
Willy Tarreaufdccded2008-08-29 18:19:04 +0200354 task_wakeup(sess->task, TASK_WOKEN_RES);
Willy Tarreau48494c02007-11-30 10:41:39 +0100355 }
356 return xferred;
357}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200358
359/* Sets server <s> down, notifies by all available means, recounts the
360 * remaining servers on the proxy and transfers queued sessions whenever
Willy Tarreau5af3a692007-07-24 23:32:33 +0200361 * possible to other servers. It automatically recomputes the number of
362 * servers, but not the map.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200363 */
Cyril Bontécd19e512010-01-31 22:34:03 +0100364void set_server_down(struct server *s)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200365{
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100366 struct server *srv;
367 struct chunk msg;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200368 int xferred;
369
Cyril Bontécd19e512010-01-31 22:34:03 +0100370 if (s->state & SRV_MAINTAIN) {
371 s->health = s->rise;
372 }
373
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100374 if (s->health == s->rise || s->tracked) {
Willy Tarreau48494c02007-11-30 10:41:39 +0100375 int srv_was_paused = s->state & SRV_GOINGDOWN;
Krzysztof Oledzki85130942007-10-22 16:21:10 +0200376
377 s->last_change = now.tv_sec;
Willy Tarreau48494c02007-11-30 10:41:39 +0100378 s->state &= ~(SRV_RUNNING | SRV_GOINGDOWN);
Willy Tarreaub625a082007-11-26 01:15:43 +0100379 s->proxy->lbprm.set_server_status_down(s);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200380
381 /* we might have sessions queued on this server and waiting for
382 * a connection. Those which are redispatchable will be queued
383 * to another server or to the proxy itself.
384 */
Willy Tarreau48494c02007-11-30 10:41:39 +0100385 xferred = redistribute_pending(s);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100386
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200387 chunk_init(&msg, trash, sizeof(trash));
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100388
Cyril Bontécd19e512010-01-31 22:34:03 +0100389 if (s->state & SRV_MAINTAIN) {
390 chunk_printf(&msg,
391 "%sServer %s/%s is DOWN for maintenance", s->state & SRV_BACKUP ? "Backup " : "",
392 s->proxy->id, s->id);
393 } else {
394 chunk_printf(&msg,
395 "%sServer %s/%s is DOWN", s->state & SRV_BACKUP ? "Backup " : "",
396 s->proxy->id, s->id);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100397
Cyril Bontécd19e512010-01-31 22:34:03 +0100398 server_status_printf(&msg, s,
399 ((!s->tracked && !(s->proxy->options2 & PR_O2_LOGHCHKS))?SSP_O_HCHK:0),
400 xferred);
401 }
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100402 Warning("%s.\n", trash);
Krzysztof Oledzki85130942007-10-22 16:21:10 +0200403
Willy Tarreau48494c02007-11-30 10:41:39 +0100404 /* we don't send an alert if the server was previously paused */
405 if (srv_was_paused)
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100406 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Willy Tarreau48494c02007-11-30 10:41:39 +0100407 else
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100408 send_log(s->proxy, LOG_ALERT, "%s.\n", trash);
Krzysztof Oledzki85130942007-10-22 16:21:10 +0200409
Willy Tarreau48494c02007-11-30 10:41:39 +0100410 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
411 set_backend_down(s->proxy);
412
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200413 s->counters.down_trans++;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100414
Krzysztof Piotr Oledzkif39c71c2009-01-30 00:52:49 +0100415 if (s->state & SRV_CHECKED)
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100416 for(srv = s->tracknext; srv; srv = srv->tracknext)
Cyril Bontécd19e512010-01-31 22:34:03 +0100417 if (! (srv->state & SRV_MAINTAIN))
418 /* Only notify tracking servers that are not already in maintenance. */
419 set_server_down(srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200420 }
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100421
Willy Tarreaubaaee002006-06-26 02:48:02 +0200422 s->health = 0; /* failure */
423}
424
Cyril Bontécd19e512010-01-31 22:34:03 +0100425void set_server_up(struct server *s) {
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100426
427 struct server *srv;
428 struct chunk msg;
429 int xferred;
430
Cyril Bontécd19e512010-01-31 22:34:03 +0100431 if (s->state & SRV_MAINTAIN) {
432 s->health = s->rise;
433 }
434
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100435 if (s->health == s->rise || s->tracked) {
436 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
437 if (s->proxy->last_change < now.tv_sec) // ignore negative times
438 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
439 s->proxy->last_change = now.tv_sec;
440 }
441
442 if (s->last_change < now.tv_sec) // ignore negative times
443 s->down_time += now.tv_sec - s->last_change;
444
445 s->last_change = now.tv_sec;
446 s->state |= SRV_RUNNING;
447
448 if (s->slowstart > 0) {
449 s->state |= SRV_WARMINGUP;
450 if (s->proxy->lbprm.algo & BE_LB_PROP_DYN) {
451 /* For dynamic algorithms, start at the first step of the weight,
452 * without multiplying by BE_WEIGHT_SCALE.
453 */
454 s->eweight = s->uweight;
455 if (s->proxy->lbprm.update_server_eweight)
456 s->proxy->lbprm.update_server_eweight(s);
457 }
458 }
459 s->proxy->lbprm.set_server_status_up(s);
460
461 /* check if we can handle some connections queued at the proxy. We
462 * will take as many as we can handle.
463 */
464 xferred = check_for_pending(s);
465
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200466 chunk_init(&msg, trash, sizeof(trash));
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100467
Cyril Bontécd19e512010-01-31 22:34:03 +0100468 if (s->state & SRV_MAINTAIN) {
469 chunk_printf(&msg,
470 "%sServer %s/%s is UP (leaving maintenance)", s->state & SRV_BACKUP ? "Backup " : "",
471 s->proxy->id, s->id);
472 } else {
473 chunk_printf(&msg,
474 "%sServer %s/%s is UP", s->state & SRV_BACKUP ? "Backup " : "",
475 s->proxy->id, s->id);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100476
Cyril Bontécd19e512010-01-31 22:34:03 +0100477 server_status_printf(&msg, s,
478 ((!s->tracked && !(s->proxy->options2 & PR_O2_LOGHCHKS))?SSP_O_HCHK:0),
479 xferred);
480 }
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100481
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100482 Warning("%s.\n", trash);
483 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100484
Krzysztof Piotr Oledzkif39c71c2009-01-30 00:52:49 +0100485 if (s->state & SRV_CHECKED)
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100486 for(srv = s->tracknext; srv; srv = srv->tracknext)
Cyril Bontécd19e512010-01-31 22:34:03 +0100487 if (! (srv->state & SRV_MAINTAIN))
488 /* Only notify tracking servers if they're not in maintenance. */
489 set_server_up(srv);
490
491 s->state &= ~SRV_MAINTAIN;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100492 }
493
494 if (s->health >= s->rise)
495 s->health = s->rise + s->fall - 1; /* OK now */
496
497}
498
499static void set_server_disabled(struct server *s) {
500
501 struct server *srv;
502 struct chunk msg;
503 int xferred;
504
505 s->state |= SRV_GOINGDOWN;
506 s->proxy->lbprm.set_server_status_down(s);
507
508 /* we might have sessions queued on this server and waiting for
509 * a connection. Those which are redispatchable will be queued
510 * to another server or to the proxy itself.
511 */
512 xferred = redistribute_pending(s);
513
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200514 chunk_init(&msg, trash, sizeof(trash));
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100515
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200516 chunk_printf(&msg,
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100517 "Load-balancing on %sServer %s/%s is disabled",
518 s->state & SRV_BACKUP ? "Backup " : "",
519 s->proxy->id, s->id);
520
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200521 server_status_printf(&msg, s,
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200522 ((!s->tracked && !(s->proxy->options2 & PR_O2_LOGHCHKS))?SSP_O_HCHK:0),
Krzysztof Piotr Oledzkib16a6072010-01-10 21:12:58 +0100523 xferred);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100524
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100525 Warning("%s.\n", trash);
526 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100527
528 if (!s->proxy->srv_bck && !s->proxy->srv_act)
529 set_backend_down(s->proxy);
530
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)
533 set_server_disabled(srv);
534}
535
536static void set_server_enabled(struct server *s) {
537
538 struct server *srv;
539 struct chunk msg;
540 int xferred;
541
542 s->state &= ~SRV_GOINGDOWN;
543 s->proxy->lbprm.set_server_status_up(s);
544
545 /* check if we can handle some connections queued at the proxy. We
546 * will take as many as we can handle.
547 */
548 xferred = check_for_pending(s);
549
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200550 chunk_init(&msg, trash, sizeof(trash));
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100551
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200552 chunk_printf(&msg,
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100553 "Load-balancing on %sServer %s/%s is enabled again",
554 s->state & SRV_BACKUP ? "Backup " : "",
555 s->proxy->id, s->id);
556
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200557 server_status_printf(&msg, s,
Krzysztof Piotr Oledzki99ab5f82009-09-27 17:28:21 +0200558 ((!s->tracked && !(s->proxy->options2 & PR_O2_LOGHCHKS))?SSP_O_HCHK:0),
Krzysztof Piotr Oledzkib16a6072010-01-10 21:12:58 +0100559 xferred);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100560
Krzysztof Piotr Oledzki9f2b9d52010-01-11 13:16:27 +0100561 Warning("%s.\n", trash);
562 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100563
Krzysztof Piotr Oledzkif39c71c2009-01-30 00:52:49 +0100564 if (s->state & SRV_CHECKED)
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100565 for(srv = s->tracknext; srv; srv = srv->tracknext)
566 set_server_enabled(srv);
567}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200568
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100569void health_adjust(struct server *s, short status) {
570
571 int failed;
572 int expire;
573
574 /* return now if observing nor health check is not enabled */
575 if (!s->observe || !s->check)
576 return;
577
578 if (s->observe >= HANA_OBS_SIZE)
579 return;
580
581 if (status >= HCHK_STATUS_SIZE || !analyze_statuses[status].desc)
582 return;
583
584 switch (analyze_statuses[status].lr[s->observe - 1]) {
585 case 1:
586 failed = 1;
587 break;
588
589 case 2:
590 failed = 0;
591 break;
592
593 default:
594 return;
595 }
596
597 if (!failed) {
598 /* good: clear consecutive_errors */
599 s->consecutive_errors = 0;
600 return;
601 }
602
603 s->consecutive_errors++;
604
605 if (s->consecutive_errors < s->consecutive_errors_limit)
606 return;
607
608 sprintf(trash, "Detected %d consecutive errors, last one was: %s",
609 s->consecutive_errors, get_analyze_status(status));
610
611 switch (s->onerror) {
612 case HANA_ONERR_FASTINTER:
613 /* force fastinter - nothing to do here as all modes force it */
614 break;
615
616 case HANA_ONERR_SUDDTH:
617 /* simulate a pre-fatal failed health check */
618 if (s->health > s->rise)
619 s->health = s->rise + 1;
620
621 /* no break - fall through */
622
623 case HANA_ONERR_FAILCHK:
624 /* simulate a failed health check */
625 set_server_check_status(s, HCHK_STATUS_HANA, trash);
626
627 if (s->health > s->rise) {
628 s->health--; /* still good */
629 s->counters.failed_checks++;
630 }
631 else
632 set_server_down(s);
633
634 break;
635
636 case HANA_ONERR_MARKDWN:
637 /* mark server down */
638 s->health = s->rise;
639 set_server_check_status(s, HCHK_STATUS_HANA, trash);
640 set_server_down(s);
641
642 break;
643
644 default:
645 /* write a warning? */
646 break;
647 }
648
649 s->consecutive_errors = 0;
650 s->counters.failed_hana++;
651
652 if (s->fastinter) {
653 expire = tick_add(now_ms, MS_TO_TICKS(s->fastinter));
654 if (s->check->expire > expire)
655 s->check->expire = expire;
656 }
657}
658
Willy Tarreauef781042010-01-27 11:53:01 +0100659static int httpchk_build_status_header(struct server *s, char *buffer)
660{
661 int sv_state;
662 int ratio;
663 int hlen = 0;
664 const char *srv_hlt_st[7] = { "DOWN", "DOWN %d/%d",
665 "UP %d/%d", "UP",
666 "NOLB %d/%d", "NOLB",
667 "no check" };
668
669 memcpy(buffer + hlen, "X-Haproxy-Server-State: ", 24);
670 hlen += 24;
671
672 if (!(s->state & SRV_CHECKED))
673 sv_state = 6; /* should obviously never happen */
674 else if (s->state & SRV_RUNNING) {
675 if (s->health == s->rise + s->fall - 1)
676 sv_state = 3; /* UP */
677 else
678 sv_state = 2; /* going down */
679
680 if (s->state & SRV_GOINGDOWN)
681 sv_state += 2;
682 } else {
683 if (s->health)
684 sv_state = 1; /* going up */
685 else
686 sv_state = 0; /* DOWN */
687 }
688
689 hlen += sprintf(buffer + hlen,
690 srv_hlt_st[sv_state],
691 (s->state & SRV_RUNNING) ? (s->health - s->rise + 1) : (s->health),
692 (s->state & SRV_RUNNING) ? (s->fall) : (s->rise));
693
694 hlen += sprintf(buffer + hlen, "; name=%s/%s; node=%s; weight=%d/%d; scur=%d/%d; qcur=%d",
695 s->proxy->id, s->id,
696 global.node,
697 (s->eweight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv,
698 (s->proxy->lbprm.tot_weight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv,
699 s->cur_sess, s->proxy->beconn - s->proxy->nbpend,
700 s->nbpend);
701
702 if ((s->state & SRV_WARMINGUP) &&
703 now.tv_sec < s->last_change + s->slowstart &&
704 now.tv_sec >= s->last_change) {
705 ratio = MAX(1, 100 * (now.tv_sec - s->last_change) / s->slowstart);
706 hlen += sprintf(buffer + hlen, "; throttle=%d%%", ratio);
707 }
708
709 buffer[hlen++] = '\r';
710 buffer[hlen++] = '\n';
711
712 return hlen;
713}
714
Willy Tarreaubaaee002006-06-26 02:48:02 +0200715/*
716 * This function is used only for server health-checks. It handles
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200717 * the connection acknowledgement. If the proxy requires L7 health-checks,
718 * it sends the request. In other cases, it calls set_server_check_status()
719 * to set s->check_status, s->check_duration and s->result.
Willy Tarreau83749182007-04-15 20:56:27 +0200720 * The function itself returns 0 if it needs some polling before being called
721 * again, otherwise 1.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200722 */
Willy Tarreau83749182007-04-15 20:56:27 +0200723static int event_srv_chk_w(int fd)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200724{
Willy Tarreau6996e152007-04-30 14:37:43 +0200725 __label__ out_wakeup, out_nowake, out_poll, out_error;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200726 struct task *t = fdtab[fd].owner;
727 struct server *s = t->context;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200728
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100729 //fprintf(stderr, "event_srv_chk_w, state=%ld\n", unlikely(fdtab[fd].state));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200730 if (unlikely(fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR))) {
Krzysztof Piotr Oledzki6492db52010-01-02 22:03:01 +0100731 int skerr, err = errno;
732 socklen_t lskerr = sizeof(skerr);
733
734 if (!getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr) && skerr)
735 err = skerr;
736
737 set_server_check_status(s, HCHK_STATUS_L4CON, strerror(err));
Willy Tarreau6996e152007-04-30 14:37:43 +0200738 goto out_error;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200739 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200740
741 /* here, we know that the connection is established */
Willy Tarreau83749182007-04-15 20:56:27 +0200742
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100743 if (!(s->result & SRV_CHK_ERROR)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200744 /* we don't want to mark 'UP' a server on which we detected an error earlier */
Willy Tarreauf3c69202006-07-09 16:42:34 +0200745 if ((s->proxy->options & PR_O_HTTP_CHK) ||
Hervé COMMOWICK698ae002010-01-12 09:25:13 +0100746 (s->proxy->options & PR_O_SMTP_CHK) ||
Willy Tarreau07a54902010-03-29 18:33:29 +0200747 (s->proxy->options2 & PR_O2_SSL3_CHK) ||
Gabor Lekenyb4c81e42010-09-29 18:17:05 +0200748 (s->proxy->options2 & PR_O2_MYSQL_CHK) ||
749 (s->proxy->options2 & PR_O2_LDAP_CHK)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200750 int ret;
Willy Tarreaue9d87882010-01-27 11:28:42 +0100751 const char *check_req = s->proxy->check_req;
752 int check_len = s->proxy->check_len;
753
Willy Tarreauf3c69202006-07-09 16:42:34 +0200754 /* we want to check if this host replies to HTTP or SSLv3 requests
Willy Tarreaubaaee002006-06-26 02:48:02 +0200755 * so we'll send the request, and won't wake the checker up now.
756 */
Willy Tarreauf3c69202006-07-09 16:42:34 +0200757
Willy Tarreau07a54902010-03-29 18:33:29 +0200758 if (s->proxy->options2 & PR_O2_SSL3_CHK) {
Willy Tarreauf3c69202006-07-09 16:42:34 +0200759 /* SSL requires that we put Unix time in the request */
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200760 int gmt_time = htonl(date.tv_sec);
Willy Tarreauf3c69202006-07-09 16:42:34 +0200761 memcpy(s->proxy->check_req + 11, &gmt_time, 4);
762 }
Willy Tarreaue9d87882010-01-27 11:28:42 +0100763 else if (s->proxy->options & PR_O_HTTP_CHK) {
764 memcpy(trash, check_req, check_len);
Willy Tarreauef781042010-01-27 11:53:01 +0100765
766 if (s->proxy->options2 & PR_O2_CHK_SNDST)
767 check_len += httpchk_build_status_header(s, trash + check_len);
768
Willy Tarreaue9d87882010-01-27 11:28:42 +0100769 trash[check_len++] = '\r';
770 trash[check_len++] = '\n';
771 trash[check_len] = '\0';
772 check_req = trash;
773 }
Willy Tarreauf3c69202006-07-09 16:42:34 +0200774
Willy Tarreaue9d87882010-01-27 11:28:42 +0100775 ret = send(fd, check_req, check_len, MSG_DONTWAIT | MSG_NOSIGNAL);
776 if (ret == check_len) {
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100777 /* we allow up to <timeout.check> if nonzero for a responce */
Willy Tarreau7cd9d942008-12-21 13:00:41 +0100778 if (s->proxy->timeout.check)
779 t->expire = tick_add_ifset(now_ms, s->proxy->timeout.check);
Willy Tarreauf161a342007-04-08 16:59:42 +0200780 EV_FD_SET(fd, DIR_RD); /* prepare for reading reply */
Willy Tarreau83749182007-04-15 20:56:27 +0200781 goto out_nowake;
782 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200783 else if (ret == 0 || errno == EAGAIN)
784 goto out_poll;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200785 else {
786 switch (errno) {
787 case ECONNREFUSED:
788 case ENETUNREACH:
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200789 set_server_check_status(s, HCHK_STATUS_L4CON, strerror(errno));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200790 break;
791
792 default:
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200793 set_server_check_status(s, HCHK_STATUS_SOCKERR, strerror(errno));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200794 }
795
Willy Tarreau6996e152007-04-30 14:37:43 +0200796 goto out_error;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200797 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200798 }
799 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200800 /* We have no data to send to check the connection, and
801 * getsockopt() will not inform us whether the connection
802 * is still pending. So we'll reuse connect() to check the
803 * state of the socket. This has the advantage of givig us
804 * the following info :
805 * - error
806 * - connecting (EALREADY, EINPROGRESS)
807 * - connected (EISCONN, 0)
808 */
809
810 struct sockaddr_in sa;
811
812 sa = (s->check_addr.sin_addr.s_addr) ? s->check_addr : s->addr;
813 sa.sin_port = htons(s->check_port);
814
815 if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == 0)
816 errno = 0;
817
818 if (errno == EALREADY || errno == EINPROGRESS)
819 goto out_poll;
820
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200821 if (errno && errno != EISCONN) {
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200822 set_server_check_status(s, HCHK_STATUS_L4CON, strerror(errno));
Willy Tarreau6996e152007-04-30 14:37:43 +0200823 goto out_error;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200824 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200825
Willy Tarreaubaaee002006-06-26 02:48:02 +0200826 /* good TCP connection is enough */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200827 set_server_check_status(s, HCHK_STATUS_L4OK, NULL);
Willy Tarreau6996e152007-04-30 14:37:43 +0200828 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200829 }
830 }
Willy Tarreau83749182007-04-15 20:56:27 +0200831 out_wakeup:
Willy Tarreaufdccded2008-08-29 18:19:04 +0200832 task_wakeup(t, TASK_WOKEN_IO);
Willy Tarreau83749182007-04-15 20:56:27 +0200833 out_nowake:
834 EV_FD_CLR(fd, DIR_WR); /* nothing more to write */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100835 fdtab[fd].ev &= ~FD_POLL_OUT;
Willy Tarreau83749182007-04-15 20:56:27 +0200836 return 1;
Willy Tarreau6996e152007-04-30 14:37:43 +0200837 out_poll:
838 /* The connection is still pending. We'll have to poll it
839 * before attempting to go further. */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100840 fdtab[fd].ev &= ~FD_POLL_OUT;
Willy Tarreau6996e152007-04-30 14:37:43 +0200841 return 0;
842 out_error:
Willy Tarreau6996e152007-04-30 14:37:43 +0200843 fdtab[fd].state = FD_STERROR;
844 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200845}
846
847
848/*
Willy Tarreauf3c69202006-07-09 16:42:34 +0200849 * This function is used only for server health-checks. It handles the server's
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200850 * reply to an HTTP request or SSL HELLO. It calls set_server_check_status() to
851 * update s->check_status, s->check_duration and s->result.
852
853 * The set_server_check_status function is called with HCHK_STATUS_L7OKD if
854 * an HTTP server replies HTTP 2xx or 3xx (valid responses), if an SMTP server
855 * returns 2xx, HCHK_STATUS_L6OK if an SSL server returns at least 5 bytes in
856 * response to an SSL HELLO (the principle is that this is enough to
857 * distinguish between an SSL server and a pure TCP relay). All other cases will
858 * call it with a proper error status like HCHK_STATUS_L7STS, HCHK_STATUS_L6RSP,
859 * etc.
860 *
861 * The function returns 0 if it needs to be called again after some polling,
862 * otherwise non-zero..
Willy Tarreaubaaee002006-06-26 02:48:02 +0200863 */
Willy Tarreau83749182007-04-15 20:56:27 +0200864static int event_srv_chk_r(int fd)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200865{
Willy Tarreau83749182007-04-15 20:56:27 +0200866 __label__ out_wakeup;
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100867 int len;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200868 struct task *t = fdtab[fd].owner;
869 struct server *s = t->context;
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200870 char *desc;
Willy Tarreau03938182010-03-17 21:52:07 +0100871 int done;
Gabor Lekenyb4c81e42010-09-29 18:17:05 +0200872 unsigned short msglen;
Willy Tarreau83749182007-04-15 20:56:27 +0200873
Willy Tarreau659d7bc2010-03-16 21:14:41 +0100874 if (unlikely((s->result & SRV_CHK_ERROR) || (fdtab[fd].state == FD_STERROR))) {
Willy Tarreau83749182007-04-15 20:56:27 +0200875 /* in case of TCP only, this tells us if the connection failed */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200876 if (!(s->result & SRV_CHK_ERROR))
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200877 set_server_check_status(s, HCHK_STATUS_SOCKERR, NULL);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200878
Willy Tarreau83749182007-04-15 20:56:27 +0200879 goto out_wakeup;
880 }
881
Willy Tarreau83749182007-04-15 20:56:27 +0200882 /* Warning! Linux returns EAGAIN on SO_ERROR if data are still available
883 * but the connection was closed on the remote end. Fortunately, recv still
884 * works correctly and we don't need to do the getsockopt() on linux.
885 */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000886
887 /* Set buffer to point to the end of the data already read, and check
888 * that there is free space remaining. If the buffer is full, proceed
889 * with running the checks without attempting another socket read.
890 */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000891
Willy Tarreau03938182010-03-17 21:52:07 +0100892 done = 0;
Willy Tarreau2c7ace02010-03-16 20:32:04 +0100893 for (len = 0; s->check_data_len < BUFSIZE; s->check_data_len += len) {
894 len = recv(fd, s->check_data + s->check_data_len, BUFSIZE - s->check_data_len, 0);
895 if (len <= 0)
896 break;
897 }
Nick Chalk57b1bf72010-03-16 15:50:46 +0000898
Willy Tarreau03938182010-03-17 21:52:07 +0100899 if (len == 0)
900 done = 1; /* connection hangup received */
901 else if (len < 0 && errno != EAGAIN) {
Willy Tarreauc1a07962010-03-16 20:55:43 +0100902 /* Report network errors only if we got no other data. Otherwise
903 * we'll let the upper layers decide whether the response is OK
904 * or not. It is very common that an RST sent by the server is
905 * reported as an error just after the last data chunk.
906 */
Willy Tarreau03938182010-03-17 21:52:07 +0100907 done = 1;
Willy Tarreauc1a07962010-03-16 20:55:43 +0100908 if (!s->check_data_len) {
909 if (!(s->result & SRV_CHK_ERROR))
910 set_server_check_status(s, HCHK_STATUS_SOCKERR, NULL);
911 goto out_wakeup;
912 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200913 }
914
Willy Tarreau03938182010-03-17 21:52:07 +0100915 /* Intermediate or complete response received.
916 * Terminate string in check_data buffer.
917 */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000918 if (s->check_data_len < BUFSIZE)
Willy Tarreau2c7ace02010-03-16 20:32:04 +0100919 s->check_data[s->check_data_len] = '\0';
Willy Tarreau03938182010-03-17 21:52:07 +0100920 else {
Willy Tarreau2c7ace02010-03-16 20:32:04 +0100921 s->check_data[s->check_data_len - 1] = '\0';
Willy Tarreau03938182010-03-17 21:52:07 +0100922 done = 1; /* buffer full, don't wait for more data */
923 }
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200924
Nick Chalk57b1bf72010-03-16 15:50:46 +0000925 /* Run the checks... */
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100926 if (s->proxy->options & PR_O_HTTP_CHK) {
Willy Tarreau03938182010-03-17 21:52:07 +0100927 if (!done && s->check_data_len < strlen("HTTP/1.0 000\r"))
928 goto wait_more_data;
929
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100930 /* Check if the server speaks HTTP 1.X */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000931 if ((s->check_data_len < strlen("HTTP/1.0 000\r")) ||
932 (memcmp(s->check_data, "HTTP/1.", 7) != 0 ||
933 (*(s->check_data + 12) != ' ' && *(s->check_data + 12) != '\r')) ||
934 !isdigit((unsigned char) *(s->check_data + 9)) || !isdigit((unsigned char) *(s->check_data + 10)) ||
935 !isdigit((unsigned char) *(s->check_data + 11))) {
936 cut_crlf(s->check_data);
937 set_server_check_status(s, HCHK_STATUS_L7RSP, s->check_data);
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200938
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100939 goto out_wakeup;
940 }
941
Nick Chalk57b1bf72010-03-16 15:50:46 +0000942 s->check_code = str2uic(s->check_data + 9);
Nick Chalk57b1bf72010-03-16 15:50:46 +0000943 desc = ltrim(s->check_data + 12, ' ');
944
Willy Tarreaubd741542010-03-16 18:46:54 +0100945 if ((s->proxy->options & PR_O_DISABLE404) &&
946 (s->state & SRV_RUNNING) && (s->check_code == 404)) {
Nick Chalk57b1bf72010-03-16 15:50:46 +0000947 /* 404 may be accepted as "stopping" only if the server was up */
948 cut_crlf(desc);
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200949 set_server_check_status(s, HCHK_STATUS_L7OKCD, desc);
Nick Chalk57b1bf72010-03-16 15:50:46 +0000950 }
Willy Tarreaubd741542010-03-16 18:46:54 +0100951 else if (s->proxy->options2 & PR_O2_EXP_TYPE) {
952 /* Run content verification check... We know we have at least 13 chars */
953 if (!httpchk_expect(s, done))
954 goto wait_more_data;
955 }
956 /* check the reply : HTTP/1.X 2xx and 3xx are OK */
957 else if (*(s->check_data + 9) == '2' || *(s->check_data + 9) == '3') {
958 cut_crlf(desc);
959 set_server_check_status(s, HCHK_STATUS_L7OKD, desc);
960 }
Nick Chalk57b1bf72010-03-16 15:50:46 +0000961 else {
962 cut_crlf(desc);
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200963 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
Nick Chalk57b1bf72010-03-16 15:50:46 +0000964 }
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100965 }
Willy Tarreau07a54902010-03-29 18:33:29 +0200966 else if (s->proxy->options2 & PR_O2_SSL3_CHK) {
Willy Tarreau03938182010-03-17 21:52:07 +0100967 if (!done && s->check_data_len < 5)
968 goto wait_more_data;
969
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100970 /* Check for SSLv3 alert or handshake */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000971 if ((s->check_data_len >= 5) && (*s->check_data == 0x15 || *s->check_data == 0x16))
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200972 set_server_check_status(s, HCHK_STATUS_L6OK, NULL);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200973 else
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200974 set_server_check_status(s, HCHK_STATUS_L6RSP, NULL);
Willy Tarreau6996e152007-04-30 14:37:43 +0200975 }
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100976 else if (s->proxy->options & PR_O_SMTP_CHK) {
Willy Tarreau03938182010-03-17 21:52:07 +0100977 if (!done && s->check_data_len < strlen("000\r"))
978 goto wait_more_data;
979
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200980 /* Check if the server speaks SMTP */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000981 if ((s->check_data_len < strlen("000\r")) ||
982 (*(s->check_data + 3) != ' ' && *(s->check_data + 3) != '\r') ||
983 !isdigit((unsigned char) *s->check_data) || !isdigit((unsigned char) *(s->check_data + 1)) ||
984 !isdigit((unsigned char) *(s->check_data + 2))) {
985 cut_crlf(s->check_data);
986 set_server_check_status(s, HCHK_STATUS_L7RSP, s->check_data);
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200987
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200988 goto out_wakeup;
989 }
990
Nick Chalk57b1bf72010-03-16 15:50:46 +0000991 s->check_code = str2uic(s->check_data);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200992
Nick Chalk57b1bf72010-03-16 15:50:46 +0000993 desc = ltrim(s->check_data + 3, ' ');
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200994 cut_crlf(desc);
995
Willy Tarreauc7dd71a2007-11-30 08:33:21 +0100996 /* Check for SMTP code 2xx (should be 250) */
Nick Chalk57b1bf72010-03-16 15:50:46 +0000997 if (*s->check_data == '2')
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200998 set_server_check_status(s, HCHK_STATUS_L7OKD, desc);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200999 else
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001000 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
Willy Tarreau6996e152007-04-30 14:37:43 +02001001 }
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001002 else if (s->proxy->options2 & PR_O2_MYSQL_CHK) {
1003 /* MySQL Error packet always begin with field_count = 0xff
1004 * contrary to OK Packet who always begin whith 0x00 */
Willy Tarreau03938182010-03-17 21:52:07 +01001005 if (!done && s->check_data_len < 5)
1006 goto wait_more_data;
1007
Nick Chalk57b1bf72010-03-16 15:50:46 +00001008 if (*(s->check_data + 4) != '\xff') {
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001009 /* We set the MySQL Version in description for information purpose
1010 * FIXME : it can be cool to use MySQL Version for other purpose,
1011 * like mark as down old MySQL server.
1012 */
Nick Chalk57b1bf72010-03-16 15:50:46 +00001013 if (s->check_data_len > 51) {
1014 desc = ltrim(s->check_data + 5, ' ');
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001015 set_server_check_status(s, HCHK_STATUS_L7OKD, desc);
1016 }
1017 else {
Willy Tarreau03938182010-03-17 21:52:07 +01001018 if (!done)
1019 goto wait_more_data;
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001020 /* it seems we have a OK packet but without a valid length,
1021 * it must be a protocol error
1022 */
Nick Chalk57b1bf72010-03-16 15:50:46 +00001023 set_server_check_status(s, HCHK_STATUS_L7RSP, s->check_data);
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001024 }
1025 }
1026 else {
1027 /* An error message is attached in the Error packet,
1028 * so we can display it ! :)
1029 */
Nick Chalk57b1bf72010-03-16 15:50:46 +00001030 desc = ltrim(s->check_data + 7, ' ');
Hervé COMMOWICK698ae002010-01-12 09:25:13 +01001031 set_server_check_status(s, HCHK_STATUS_L7STS, desc);
1032 }
1033 }
Gabor Lekenyb4c81e42010-09-29 18:17:05 +02001034 else if (s->proxy->options2 & PR_O2_LDAP_CHK) {
1035 if (!done && s->check_data_len < 14)
1036 goto wait_more_data;
1037
1038 /* Check if the server speaks LDAP (ASN.1/BER)
1039 * http://en.wikipedia.org/wiki/Basic_Encoding_Rules
1040 * http://tools.ietf.org/html/rfc4511
1041 */
1042
1043 /* http://tools.ietf.org/html/rfc4511#section-4.1.1
1044 * LDAPMessage: 0x30: SEQUENCE
1045 */
1046 if ((s->check_data_len < 14) || (*(s->check_data) != '\x30')) {
1047 set_server_check_status(s, HCHK_STATUS_L7RSP, "Not LDAPv3 protocol");
1048 }
1049 else {
1050 /* size of LDAPMessage */
1051 msglen = (*(s->check_data + 1) & 0x80) ? (*(s->check_data + 1) & 0x7f) : 0;
1052
1053 /* http://tools.ietf.org/html/rfc4511#section-4.2.2
1054 * messageID: 0x02 0x01 0x01: INTEGER 1
1055 * protocolOp: 0x61: bindResponse
1056 */
1057 if ((msglen > 2) ||
1058 (memcmp(s->check_data + 2 + msglen, "\x02\x01\x01\x61", 4) != 0)) {
1059 set_server_check_status(s, HCHK_STATUS_L7RSP, "Not LDAPv3 protocol");
1060
1061 goto out_wakeup;
1062 }
1063
1064 /* size of bindResponse */
1065 msglen += (*(s->check_data + msglen + 6) & 0x80) ? (*(s->check_data + msglen + 6) & 0x7f) : 0;
1066
1067 /* http://tools.ietf.org/html/rfc4511#section-4.1.9
1068 * ldapResult: 0x0a 0x01: ENUMERATION
1069 */
1070 if ((msglen > 4) ||
1071 (memcmp(s->check_data + 7 + msglen, "\x0a\x01", 2) != 0)) {
1072 set_server_check_status(s, HCHK_STATUS_L7RSP, "Not LDAPv3 protocol");
1073
1074 goto out_wakeup;
1075 }
1076
1077 /* http://tools.ietf.org/html/rfc4511#section-4.1.9
1078 * resultCode
1079 */
1080 s->check_code = *(s->check_data + msglen + 9);
1081 if (s->check_code) {
1082 set_server_check_status(s, HCHK_STATUS_L7STS, "See RFC: http://tools.ietf.org/html/rfc4511#section-4.1.9");
1083 } else {
1084 set_server_check_status(s, HCHK_STATUS_L7OKD, "Success");
1085 }
1086 }
1087 }
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001088 else {
1089 /* other checks are valid if the connection succeeded anyway */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001090 set_server_check_status(s, HCHK_STATUS_L4OK, NULL);
Willy Tarreau23677902007-05-08 23:50:35 +02001091 }
Willy Tarreau83749182007-04-15 20:56:27 +02001092
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001093 out_wakeup:
1094 if (s->result & SRV_CHK_ERROR)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001095 fdtab[fd].state = FD_STERROR;
1096
Nick Chalk57b1bf72010-03-16 15:50:46 +00001097 /* Reset the check buffer... */
1098 *s->check_data = '\0';
1099 s->check_data_len = 0;
1100
Willy Tarreau03938182010-03-17 21:52:07 +01001101 /* Close the connection... */
1102 shutdown(fd, SHUT_RDWR);
Willy Tarreauf161a342007-04-08 16:59:42 +02001103 EV_FD_CLR(fd, DIR_RD);
Willy Tarreaufdccded2008-08-29 18:19:04 +02001104 task_wakeup(t, TASK_WOKEN_IO);
Willy Tarreaud6f087e2008-01-18 17:20:13 +01001105 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau83749182007-04-15 20:56:27 +02001106 return 1;
Willy Tarreau03938182010-03-17 21:52:07 +01001107
1108 wait_more_data:
1109 fdtab[fd].ev &= ~FD_POLL_IN;
1110 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001111}
1112
1113/*
1114 * manages a server health-check. Returns
1115 * the time the task accepts to wait, or TIME_ETERNITY for infinity.
1116 */
Willy Tarreau26c25062009-03-08 09:38:41 +01001117struct task *process_chk(struct task *t)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001118{
Willy Tarreaue3838802009-03-21 18:58:32 +01001119 int attempts = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001120 struct server *s = t->context;
1121 struct sockaddr_in sa;
1122 int fd;
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001123 int rv;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001124
1125 //fprintf(stderr, "process_chk: task=%p\n", t);
1126
1127 new_chk:
Willy Tarreaue3838802009-03-21 18:58:32 +01001128 if (attempts++ > 0) {
1129 /* we always fail to create a server, let's stop insisting... */
1130 while (tick_is_expired(t->expire, now_ms))
1131 t->expire = tick_add(t->expire, MS_TO_TICKS(s->inter));
1132 return t;
1133 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001134 fd = s->curfd;
1135 if (fd < 0) { /* no check currently running */
1136 //fprintf(stderr, "process_chk: 2\n");
Willy Tarreau26c25062009-03-08 09:38:41 +01001137 if (!tick_is_expired(t->expire, now_ms)) /* woke up too early */
1138 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001139
1140 /* we don't send any health-checks when the proxy is stopped or when
1141 * the server should not be checked.
1142 */
Cyril Bontécd19e512010-01-31 22:34:03 +01001143 if (!(s->state & SRV_CHECKED) || s->proxy->state == PR_STSTOPPED || (s->state & SRV_MAINTAIN)) {
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001144 while (tick_is_expired(t->expire, now_ms))
1145 t->expire = tick_add(t->expire, MS_TO_TICKS(s->inter));
Willy Tarreau26c25062009-03-08 09:38:41 +01001146 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001147 }
1148
1149 /* we'll initiate a new check */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001150 set_server_check_status(s, HCHK_STATUS_START, NULL);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001151 if ((fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) != -1) {
1152 if ((fd < global.maxsock) &&
1153 (fcntl(fd, F_SETFL, O_NONBLOCK) != -1) &&
1154 (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one)) != -1)) {
1155 //fprintf(stderr, "process_chk: 3\n");
1156
Willy Tarreau9edd1612007-10-18 18:07:48 +02001157 if (s->proxy->options & PR_O_TCP_NOLING) {
1158 /* We don't want to useless data */
1159 setsockopt(fd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
1160 }
Willy Tarreau2ea3abb2007-03-25 16:45:16 +02001161
Willy Tarreau0f03c6f2007-03-25 20:46:19 +02001162 if (s->check_addr.sin_addr.s_addr)
1163 /* we'll connect to the check addr specified on the server */
Willy Tarreau2ea3abb2007-03-25 16:45:16 +02001164 sa = s->check_addr;
Willy Tarreau2ea3abb2007-03-25 16:45:16 +02001165 else
Willy Tarreau0f03c6f2007-03-25 20:46:19 +02001166 /* we'll connect to the addr on the server */
Willy Tarreau2ea3abb2007-03-25 16:45:16 +02001167 sa = s->addr;
Willy Tarreau0f03c6f2007-03-25 20:46:19 +02001168
Willy Tarreaubaaee002006-06-26 02:48:02 +02001169 /* we'll connect to the check port on the server */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001170 sa.sin_port = htons(s->check_port);
1171
1172 /* allow specific binding :
1173 * - server-specific at first
1174 * - proxy-specific next
1175 */
1176 if (s->state & SRV_BIND_SRC) {
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001177 struct sockaddr_in *remote = NULL;
1178 int ret, flags = 0;
Willy Tarreau163c5322006-11-14 16:18:41 +01001179
Willy Tarreaucf1d5722008-02-14 20:28:18 +01001180#if defined(CONFIG_HAP_CTTPROXY) || defined(CONFIG_HAP_LINUX_TPROXY)
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001181 if ((s->state & SRV_TPROXY_MASK) == SRV_TPROXY_ADDR) {
1182 remote = (struct sockaddr_in *)&s->tproxy_addr;
1183 flags = 3;
1184 }
Willy Tarreaucf1d5722008-02-14 20:28:18 +01001185#endif
Willy Tarreauc76721d2009-02-04 20:20:58 +01001186#ifdef SO_BINDTODEVICE
1187 /* Note: this might fail if not CAP_NET_RAW */
1188 if (s->iface_name)
1189 setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
Willy Tarreau604e8302009-03-06 00:48:23 +01001190 s->iface_name, s->iface_len + 1);
Willy Tarreauc76721d2009-02-04 20:20:58 +01001191#endif
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001192 if (s->sport_range) {
1193 int bind_attempts = 10; /* should be more than enough to find a spare port */
1194 struct sockaddr_in src;
1195
1196 ret = 1;
1197 src = s->source_addr;
1198
1199 do {
1200 /* note: in case of retry, we may have to release a previously
1201 * allocated port, hence this loop's construct.
1202 */
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001203 port_range_release_port(fdinfo[fd].port_range, fdinfo[fd].local_port);
1204 fdinfo[fd].port_range = NULL;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001205
1206 if (!bind_attempts)
1207 break;
1208 bind_attempts--;
1209
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001210 fdinfo[fd].local_port = port_range_alloc_port(s->sport_range);
1211 if (!fdinfo[fd].local_port)
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001212 break;
1213
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001214 fdinfo[fd].port_range = s->sport_range;
1215 src.sin_port = htons(fdinfo[fd].local_port);
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001216
1217 ret = tcpv4_bind_socket(fd, flags, &src, remote);
1218 } while (ret != 0); /* binding NOK */
1219 }
1220 else {
1221 ret = tcpv4_bind_socket(fd, flags, &s->source_addr, remote);
1222 }
1223
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001224 if (ret) {
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001225 set_server_check_status(s, HCHK_STATUS_SOCKERR, NULL);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001226 switch (ret) {
1227 case 1:
1228 Alert("Cannot bind to source address before connect() for server %s/%s. Aborting.\n",
1229 s->proxy->id, s->id);
1230 break;
1231 case 2:
Willy Tarreau163c5322006-11-14 16:18:41 +01001232 Alert("Cannot bind to tproxy source address before connect() for server %s/%s. Aborting.\n",
1233 s->proxy->id, s->id);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001234 break;
Willy Tarreau163c5322006-11-14 16:18:41 +01001235 }
1236 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001237 }
1238 else if (s->proxy->options & PR_O_BIND_SRC) {
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001239 struct sockaddr_in *remote = NULL;
1240 int ret, flags = 0;
1241
Willy Tarreaucf1d5722008-02-14 20:28:18 +01001242#if defined(CONFIG_HAP_CTTPROXY) || defined(CONFIG_HAP_LINUX_TPROXY)
Willy Tarreau163c5322006-11-14 16:18:41 +01001243 if ((s->proxy->options & PR_O_TPXY_MASK) == PR_O_TPXY_ADDR) {
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001244 remote = (struct sockaddr_in *)&s->proxy->tproxy_addr;
1245 flags = 3;
1246 }
Willy Tarreaucf1d5722008-02-14 20:28:18 +01001247#endif
Willy Tarreaud53f96b2009-02-04 18:46:54 +01001248#ifdef SO_BINDTODEVICE
1249 /* Note: this might fail if not CAP_NET_RAW */
1250 if (s->proxy->iface_name)
1251 setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
Willy Tarreau604e8302009-03-06 00:48:23 +01001252 s->proxy->iface_name, s->proxy->iface_len + 1);
Willy Tarreaud53f96b2009-02-04 18:46:54 +01001253#endif
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001254 ret = tcpv4_bind_socket(fd, flags, &s->proxy->source_addr, remote);
1255 if (ret) {
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001256 set_server_check_status(s, HCHK_STATUS_SOCKERR, NULL);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001257 switch (ret) {
1258 case 1:
1259 Alert("Cannot bind to source address before connect() for %s '%s'. Aborting.\n",
1260 proxy_type_str(s->proxy), s->proxy->id);
1261 break;
1262 case 2:
Willy Tarreau2b5652f2006-12-31 17:46:05 +01001263 Alert("Cannot bind to tproxy source address before connect() for %s '%s'. Aborting.\n",
1264 proxy_type_str(s->proxy), s->proxy->id);
Willy Tarreaue8c66af2008-01-13 18:40:14 +01001265 break;
Willy Tarreau163c5322006-11-14 16:18:41 +01001266 }
1267 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001268 }
1269
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001270 if (s->result == SRV_CHK_UNKNOWN) {
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +04001271#if defined(TCP_QUICKACK)
Willy Tarreau1274bc42009-07-15 07:16:31 +02001272 /* disabling tcp quick ack now allows
1273 * the request to leave the machine with
1274 * the first ACK.
1275 */
1276 if (s->proxy->options2 & PR_O2_SMARTCON)
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +04001277 setsockopt(fd, IPPROTO_TCP, TCP_QUICKACK, (char *) &zero, sizeof(zero));
Willy Tarreau1274bc42009-07-15 07:16:31 +02001278#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +02001279 if ((connect(fd, (struct sockaddr *)&sa, sizeof(sa)) != -1) || (errno == EINPROGRESS)) {
1280 /* OK, connection in progress or established */
1281
1282 //fprintf(stderr, "process_chk: 4\n");
1283
1284 s->curfd = fd; /* that's how we know a test is in progress ;-) */
Willy Tarreau7a966482007-04-15 10:58:02 +02001285 fd_insert(fd);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001286 fdtab[fd].owner = t;
Willy Tarreau54469402006-07-29 16:59:06 +02001287 fdtab[fd].cb[DIR_RD].f = &event_srv_chk_r;
1288 fdtab[fd].cb[DIR_RD].b = NULL;
1289 fdtab[fd].cb[DIR_WR].f = &event_srv_chk_w;
1290 fdtab[fd].cb[DIR_WR].b = NULL;
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001291 fdinfo[fd].peeraddr = (struct sockaddr *)&sa;
1292 fdinfo[fd].peerlen = sizeof(sa);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001293 fdtab[fd].state = FD_STCONN; /* connection in progress */
Willy Tarreaufb14edc2009-06-14 15:24:37 +02001294 fdtab[fd].flags = FD_FL_TCP | FD_FL_TCP_NODELAY;
Willy Tarreauf161a342007-04-08 16:59:42 +02001295 EV_FD_SET(fd, DIR_WR); /* for connect status */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001296#ifdef DEBUG_FULL
Willy Tarreauf161a342007-04-08 16:59:42 +02001297 assert (!EV_FD_ISSET(fd, DIR_RD));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001298#endif
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001299 //fprintf(stderr, "process_chk: 4+, %lu\n", __tv_to_ms(&s->proxy->timeout.connect));
1300 /* we allow up to min(inter, timeout.connect) for a connection
1301 * to establish but only when timeout.check is set
1302 * as it may be to short for a full check otherwise
1303 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001304 t->expire = tick_add(now_ms, MS_TO_TICKS(s->inter));
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001305
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001306 if (s->proxy->timeout.check && s->proxy->timeout.connect) {
1307 int t_con = tick_add(now_ms, s->proxy->timeout.connect);
1308 t->expire = tick_first(t->expire, t_con);
Willy Tarreau60548192008-02-17 11:34:10 +01001309 }
Willy Tarreau26c25062009-03-08 09:38:41 +01001310 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001311 }
1312 else if (errno != EALREADY && errno != EISCONN && errno != EAGAIN) {
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +02001313 /* a real error */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001314
1315 switch (errno) {
1316 /* FIXME: is it possible to get ECONNREFUSED/ENETUNREACH with O_NONBLOCK? */
1317 case ECONNREFUSED:
1318 case ENETUNREACH:
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001319 set_server_check_status(s, HCHK_STATUS_L4CON, strerror(errno));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001320 break;
1321
1322 default:
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001323 set_server_check_status(s, HCHK_STATUS_SOCKERR, strerror(errno));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001324 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001325 }
1326 }
1327 }
Willy Tarreau8d5d77e2009-10-18 07:25:52 +02001328 port_range_release_port(fdinfo[fd].port_range, fdinfo[fd].local_port);
1329 fdinfo[fd].port_range = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001330 close(fd); /* socket creation error */
1331 }
1332
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001333 if (s->result == SRV_CHK_UNKNOWN) { /* nothing done */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001334 //fprintf(stderr, "process_chk: 6\n");
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 Tarreaubaaee002006-06-26 02:48:02 +02001337 goto new_chk; /* may be we should initialize a new check */
1338 }
1339
1340 /* here, we have seen a failure */
1341 if (s->health > s->rise) {
1342 s->health--; /* still good */
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +02001343 s->counters.failed_checks++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001344 }
1345 else
1346 set_server_down(s);
1347
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001348 //fprintf(stderr, "process_chk: 7, %lu\n", __tv_to_ms(&s->proxy->timeout.connect));
1349 /* we allow up to min(inter, timeout.connect) for a connection
1350 * to establish but only when timeout.check is set
1351 * as it may be to short for a full check otherwise
1352 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001353 while (tick_is_expired(t->expire, now_ms)) {
1354 int t_con;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001355
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001356 t_con = tick_add(t->expire, s->proxy->timeout.connect);
1357 t->expire = tick_add(t->expire, MS_TO_TICKS(s->inter));
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001358
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001359 if (s->proxy->timeout.check)
1360 t->expire = tick_first(t->expire, t_con);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001361 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001362 goto new_chk;
1363 }
1364 else {
1365 //fprintf(stderr, "process_chk: 8\n");
1366 /* there was a test running */
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001367 if ((s->result & (SRV_CHK_ERROR|SRV_CHK_RUNNING)) == SRV_CHK_RUNNING) { /* good server detected */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001368 //fprintf(stderr, "process_chk: 9\n");
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001369
Willy Tarreau9909fc12007-11-30 17:42:05 +01001370 if (s->state & SRV_WARMINGUP) {
1371 if (now.tv_sec < s->last_change || now.tv_sec >= s->last_change + s->slowstart) {
1372 s->state &= ~SRV_WARMINGUP;
1373 if (s->proxy->lbprm.algo & BE_LB_PROP_DYN)
1374 s->eweight = s->uweight * BE_WEIGHT_SCALE;
1375 if (s->proxy->lbprm.update_server_eweight)
1376 s->proxy->lbprm.update_server_eweight(s);
1377 }
1378 else if (s->proxy->lbprm.algo & BE_LB_PROP_DYN) {
1379 /* for dynamic algorithms, let's update the weight */
Willy Tarreau5542af62007-12-03 02:04:00 +01001380 s->eweight = (BE_WEIGHT_SCALE * (now.tv_sec - s->last_change) +
1381 s->slowstart - 1) / s->slowstart;
Willy Tarreau9909fc12007-11-30 17:42:05 +01001382 s->eweight *= s->uweight;
1383 if (s->proxy->lbprm.update_server_eweight)
1384 s->proxy->lbprm.update_server_eweight(s);
1385 }
1386 /* probably that we can refill this server with a bit more connections */
1387 check_for_pending(s);
1388 }
1389
Willy Tarreau48494c02007-11-30 10:41:39 +01001390 /* we may have to add/remove this server from the LB group */
1391 if ((s->state & SRV_RUNNING) && (s->proxy->options & PR_O_DISABLE404)) {
1392 if ((s->state & SRV_GOINGDOWN) &&
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +01001393 ((s->result & (SRV_CHK_RUNNING|SRV_CHK_DISABLE)) == SRV_CHK_RUNNING))
1394 set_server_enabled(s);
Willy Tarreau48494c02007-11-30 10:41:39 +01001395 else if (!(s->state & SRV_GOINGDOWN) &&
1396 ((s->result & (SRV_CHK_RUNNING | SRV_CHK_DISABLE)) ==
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +01001397 (SRV_CHK_RUNNING | SRV_CHK_DISABLE)))
1398 set_server_disabled(s);
Willy Tarreau48494c02007-11-30 10:41:39 +01001399 }
1400
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001401 if (s->health < s->rise + s->fall - 1) {
1402 s->health++; /* was bad, stays for a while */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001403
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +01001404 set_server_up(s);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001405 }
1406 s->curfd = -1; /* no check running anymore */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001407 fd_delete(fd);
Willy Tarreau44ec0f02007-10-14 23:47:04 +02001408
1409 rv = 0;
1410 if (global.spread_checks > 0) {
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001411 rv = srv_getinter(s) * global.spread_checks / 100;
Willy Tarreau44ec0f02007-10-14 23:47:04 +02001412 rv -= (int) (2 * rv * (rand() / (RAND_MAX + 1.0)));
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001413 //fprintf(stderr, "process_chk(%p): (%d+/-%d%%) random=%d\n", s, srv_getinter(s), global.spread_checks, rv);
Willy Tarreau44ec0f02007-10-14 23:47:04 +02001414 }
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001415 t->expire = tick_add(now_ms, MS_TO_TICKS(srv_getinter(s) + rv));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001416 goto new_chk;
1417 }
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001418 else if ((s->result & SRV_CHK_ERROR) || tick_is_expired(t->expire, now_ms)) {
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001419 if (!(s->result & SRV_CHK_ERROR)) {
1420 if (!EV_FD_ISSET(fd, DIR_RD)) {
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001421 set_server_check_status(s, HCHK_STATUS_L4TOUT, NULL);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001422 } else {
Willy Tarreau07a54902010-03-29 18:33:29 +02001423 if (s->proxy->options2 & PR_O2_SSL3_CHK)
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001424 set_server_check_status(s, HCHK_STATUS_L6TOUT, NULL);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001425 else /* HTTP, SMTP */
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +02001426 set_server_check_status(s, HCHK_STATUS_L7TOUT, NULL);
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001427 }
1428 }
1429
Willy Tarreaubaaee002006-06-26 02:48:02 +02001430 //fprintf(stderr, "process_chk: 10\n");
1431 /* failure or timeout detected */
1432 if (s->health > s->rise) {
1433 s->health--; /* still good */
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +02001434 s->counters.failed_checks++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001435 }
1436 else
1437 set_server_down(s);
1438 s->curfd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001439 fd_delete(fd);
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001440
1441 rv = 0;
1442 if (global.spread_checks > 0) {
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001443 rv = srv_getinter(s) * global.spread_checks / 100;
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001444 rv -= (int) (2 * rv * (rand() / (RAND_MAX + 1.0)));
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001445 //fprintf(stderr, "process_chk(%p): (%d+/-%d%%) random=%d\n", s, srv_getinter(s), global.spread_checks, rv);
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001446 }
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001447 t->expire = tick_add(now_ms, MS_TO_TICKS(srv_getinter(s) + rv));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001448 goto new_chk;
1449 }
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001450 /* if result is unknown and there's no timeout, we have to wait again */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001451 }
1452 //fprintf(stderr, "process_chk: 11\n");
Willy Tarreauc7dd71a2007-11-30 08:33:21 +01001453 s->result = SRV_CHK_UNKNOWN;
Willy Tarreau26c25062009-03-08 09:38:41 +01001454 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001455}
1456
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001457/*
1458 * Start health-check.
1459 * Returns 0 if OK, -1 if error, and prints the error in this case.
1460 */
1461int start_checks() {
1462
1463 struct proxy *px;
1464 struct server *s;
1465 struct task *t;
1466 int nbchk=0, mininter=0, srvpos=0;
1467
Willy Tarreau2c43a1e2007-10-14 23:05:39 +02001468 /* 1- count the checkers to run simultaneously.
1469 * We also determine the minimum interval among all of those which
1470 * have an interval larger than SRV_CHK_INTER_THRES. This interval
1471 * will be used to spread their start-up date. Those which have
1472 * a shorter interval will start independantly and will not dictate
1473 * too short an interval for all others.
1474 */
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001475 for (px = proxy; px; px = px->next) {
1476 for (s = px->srv; s; s = s->next) {
1477 if (!(s->state & SRV_CHECKED))
1478 continue;
1479
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01001480 if ((srv_getinter(s) >= SRV_CHK_INTER_THRES) &&
1481 (!mininter || mininter > srv_getinter(s)))
1482 mininter = srv_getinter(s);
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001483
1484 nbchk++;
1485 }
1486 }
1487
1488 if (!nbchk)
1489 return 0;
1490
1491 srand((unsigned)time(NULL));
1492
1493 /*
1494 * 2- start them as far as possible from each others. For this, we will
1495 * start them after their interval set to the min interval divided by
1496 * the number of servers, weighted by the server's position in the list.
1497 */
1498 for (px = proxy; px; px = px->next) {
1499 for (s = px->srv; s; s = s->next) {
1500 if (!(s->state & SRV_CHECKED))
1501 continue;
1502
Willy Tarreaua4613182009-03-21 18:13:21 +01001503 if ((t = task_new()) == NULL) {
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001504 Alert("Starting [%s:%s] check: out of memory.\n", px->id, s->id);
1505 return -1;
1506 }
1507
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02001508 s->check = t;
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001509 t->process = process_chk;
1510 t->context = s;
1511
1512 /* check this every ms */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02001513 t->expire = tick_add(now_ms,
1514 MS_TO_TICKS(((mininter && mininter >= srv_getinter(s)) ?
1515 mininter : srv_getinter(s)) * srvpos / nbchk));
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +02001516 s->check_start = now;
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001517 task_queue(t);
1518
1519 srvpos++;
1520 }
1521 }
1522 return 0;
1523}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001524
1525/*
Willy Tarreaubd741542010-03-16 18:46:54 +01001526 * Perform content verification check on data in s->check_data buffer.
1527 * The buffer MUST be terminated by a null byte before calling this function.
1528 * Sets server status appropriately. The caller is responsible for ensuring
1529 * that the buffer contains at least 13 characters. If <done> is zero, we may
1530 * return 0 to indicate that data is required to decide of a match.
1531 */
1532static int httpchk_expect(struct server *s, int done)
1533{
1534 static char status_msg[] = "HTTP status check returned code <000>";
1535 char status_code[] = "000";
1536 char *contentptr;
1537 int crlf;
1538 int ret;
1539
1540 switch (s->proxy->options2 & PR_O2_EXP_TYPE) {
1541 case PR_O2_EXP_STS:
1542 case PR_O2_EXP_RSTS:
1543 memcpy(status_code, s->check_data + 9, 3);
1544 memcpy(status_msg + strlen(status_msg) - 4, s->check_data + 9, 3);
1545
1546 if ((s->proxy->options2 & PR_O2_EXP_TYPE) == PR_O2_EXP_STS)
1547 ret = strncmp(s->proxy->expect_str, status_code, 3) == 0;
1548 else
1549 ret = regexec(s->proxy->expect_regex, status_code, MAX_MATCH, pmatch, 0) == 0;
1550
1551 /* we necessarily have the response, so there are no partial failures */
1552 if (s->proxy->options2 & PR_O2_EXP_INV)
1553 ret = !ret;
1554
1555 set_server_check_status(s, ret ? HCHK_STATUS_L7OKD : HCHK_STATUS_L7STS, status_msg);
1556 break;
1557
1558 case PR_O2_EXP_STR:
1559 case PR_O2_EXP_RSTR:
1560 /* very simple response parser: ignore CR and only count consecutive LFs,
1561 * stop with contentptr pointing to first char after the double CRLF or
1562 * to '\0' if crlf < 2.
1563 */
1564 crlf = 0;
1565 for (contentptr = s->check_data; *contentptr; contentptr++) {
1566 if (crlf >= 2)
1567 break;
1568 if (*contentptr == '\r')
1569 continue;
1570 else if (*contentptr == '\n')
1571 crlf++;
1572 else
1573 crlf = 0;
1574 }
1575
1576 /* Check that response contains a body... */
1577 if (crlf < 2) {
1578 if (!done)
1579 return 0;
1580
1581 set_server_check_status(s, HCHK_STATUS_L7RSP,
1582 "HTTP content check could not find a response body");
1583 return 1;
1584 }
1585
1586 /* Check that response body is not empty... */
1587 if (*contentptr == '\0') {
1588 set_server_check_status(s, HCHK_STATUS_L7RSP,
1589 "HTTP content check found empty response body");
1590 return 1;
1591 }
1592
1593 /* Check the response content against the supplied string
1594 * or regex... */
1595 if ((s->proxy->options2 & PR_O2_EXP_TYPE) == PR_O2_EXP_STR)
1596 ret = strstr(contentptr, s->proxy->expect_str) != NULL;
1597 else
1598 ret = regexec(s->proxy->expect_regex, contentptr, MAX_MATCH, pmatch, 0) == 0;
1599
1600 /* if we don't match, we may need to wait more */
1601 if (!ret && !done)
1602 return 0;
1603
1604 if (ret) {
1605 /* content matched */
1606 if (s->proxy->options2 & PR_O2_EXP_INV)
1607 set_server_check_status(s, HCHK_STATUS_L7RSP,
1608 "HTTP check matched unwanted content");
1609 else
1610 set_server_check_status(s, HCHK_STATUS_L7OKD,
1611 "HTTP content check matched");
1612 }
1613 else {
1614 if (s->proxy->options2 & PR_O2_EXP_INV)
1615 set_server_check_status(s, HCHK_STATUS_L7OKD,
1616 "HTTP check did not match unwanted content");
1617 else
1618 set_server_check_status(s, HCHK_STATUS_L7RSP,
1619 "HTTP content check did not match");
1620 }
1621 break;
1622 }
1623 return 1;
1624}
1625
1626/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001627 * Local variables:
1628 * c-indent-level: 8
1629 * c-basic-offset: 8
1630 * End:
1631 */