blob: 22050630b09cf976431b77b2923f2ff4f806be2b [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>
Simon Horman0ba0e4a2015-01-30 11:23:00 +090018#include <stdarg.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020019#include <stdio.h>
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +020020#include <stdlib.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020021#include <string.h>
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +020022#include <time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020023#include <unistd.h>
Willy Tarreau9f6dc722019-03-01 11:15:10 +010024#include <sys/resource.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020025#include <sys/socket.h>
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +040026#include <sys/types.h>
Simon Horman98637e52014-06-20 12:30:16 +090027#include <sys/wait.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020028#include <netinet/in.h>
Willy Tarreau1274bc42009-07-15 07:16:31 +020029#include <netinet/tcp.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020030#include <arpa/inet.h>
31
Willy Tarreau122eba92020-06-04 10:15:32 +020032#include <haproxy/action.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020033#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020034#include <haproxy/arg.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020035#include <haproxy/cfgparse.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020036#include <haproxy/check.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020037#include <haproxy/chunk.h>
Willy Tarreau7c18b542020-06-11 09:23:02 +020038#include <haproxy/dgram.h>
Christopher Fauletb381a502020-11-25 13:47:00 +010039#include <haproxy/dynbuf-t.h>
Willy Tarreaubcc67332020-06-05 15:31:31 +020040#include <haproxy/extcheck.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020041#include <haproxy/fd.h>
42#include <haproxy/global.h>
43#include <haproxy/h1.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020044#include <haproxy/http.h>
Willy Tarreau87735332020-06-04 09:08:41 +020045#include <haproxy/http_htx.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020046#include <haproxy/htx.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020047#include <haproxy/istbuf.h>
48#include <haproxy/list.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020049#include <haproxy/log.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020050#include <haproxy/mailers.h>
51#include <haproxy/port_range.h>
52#include <haproxy/proto_tcp.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020053#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020054#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020055#include <haproxy/queue.h>
56#include <haproxy/regex.h>
Emeric Brunc9437992021-02-12 19:42:55 +010057#include <haproxy/resolvers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020058#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020059#include <haproxy/server.h>
Willy Tarreau209108d2020-06-04 20:30:20 +020060#include <haproxy/ssl_sock.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020061#include <haproxy/stats-t.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020062#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020063#include <haproxy/task.h>
Willy Tarreau51cd5952020-06-05 12:25:38 +020064#include <haproxy/tcpcheck.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020065#include <haproxy/thread.h>
66#include <haproxy/time.h>
67#include <haproxy/tools.h>
Christopher Faulet147b8c92021-04-10 09:00:38 +020068#include <haproxy/trace.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020069#include <haproxy/vars.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020070
Christopher Faulet147b8c92021-04-10 09:00:38 +020071/* trace source and events */
72static void check_trace(enum trace_level level, uint64_t mask,
73 const struct trace_source *src,
74 const struct ist where, const struct ist func,
75 const void *a1, const void *a2, const void *a3, const void *a4);
76
77/* The event representation is split like this :
78 * check - check
79 *
80 * CHECK_EV_* macros are defined in <haproxy/check.h>
81 */
82static const struct trace_event check_trace_events[] = {
83 { .mask = CHK_EV_TASK_WAKE, .name = "task_wake", .desc = "Check task woken up" },
84 { .mask = CHK_EV_HCHK_START, .name = "hchck_start", .desc = "Health-check started" },
85 { .mask = CHK_EV_HCHK_WAKE, .name = "hchck_wake", .desc = "Health-check woken up" },
86 { .mask = CHK_EV_HCHK_RUN, .name = "hchck_run", .desc = "Health-check running" },
87 { .mask = CHK_EV_HCHK_END, .name = "hchck_end", .desc = "Health-check terminated" },
88 { .mask = CHK_EV_HCHK_SUCC, .name = "hchck_succ", .desc = "Health-check success" },
89 { .mask = CHK_EV_HCHK_ERR, .name = "hchck_err", .desc = "Health-check failure" },
90
91 { .mask = CHK_EV_TCPCHK_EVAL, .name = "tcp_check_eval", .desc = "tcp-check rules evaluation" },
92 { .mask = CHK_EV_TCPCHK_ERR, .name = "tcp_check_err", .desc = "tcp-check evaluation error" },
93 { .mask = CHK_EV_TCPCHK_CONN, .name = "tcp_check_conn", .desc = "tcp-check connection rule" },
94 { .mask = CHK_EV_TCPCHK_SND, .name = "tcp_check_send", .desc = "tcp-check send rule" },
95 { .mask = CHK_EV_TCPCHK_EXP, .name = "tcp_check_expect", .desc = "tcp-check expect rule" },
96 { .mask = CHK_EV_TCPCHK_ACT, .name = "tcp_check_action", .desc = "tcp-check action rule" },
97
98 { .mask = CHK_EV_RX_DATA, .name = "rx_data", .desc = "receipt of data" },
99 { .mask = CHK_EV_RX_BLK, .name = "rx_blk", .desc = "receipt blocked" },
100 { .mask = CHK_EV_RX_ERR, .name = "rx_err", .desc = "receipt error" },
101
102 { .mask = CHK_EV_TX_DATA, .name = "tx_data", .desc = "transmission of data" },
103 { .mask = CHK_EV_TX_BLK, .name = "tx_blk", .desc = "transmission blocked" },
104 { .mask = CHK_EV_TX_ERR, .name = "tx_err", .desc = "transmission error" },
105
106 {}
107};
108
109static const struct name_desc check_trace_lockon_args[4] = {
110 /* arg1 */ { /* already used by the check */ },
111 /* arg2 */ { },
112 /* arg3 */ { },
113 /* arg4 */ { }
114};
115
116static const struct name_desc check_trace_decoding[] = {
117#define CHK_VERB_CLEAN 1
118 { .name="clean", .desc="only user-friendly stuff, generally suitable for level \"user\"" },
119#define CHK_VERB_MINIMAL 2
120 { .name="minimal", .desc="report info on stream and stream-interfaces" },
121#define CHK_VERB_SIMPLE 3
122 { .name="simple", .desc="add info on request and response channels" },
123#define CHK_VERB_ADVANCED 4
124 { .name="advanced", .desc="add info on channel's buffer for data and developer levels only" },
125#define CHK_VERB_COMPLETE 5
126 { .name="complete", .desc="add info on channel's buffer" },
127 { /* end */ }
128};
129
130struct trace_source trace_check = {
131 .name = IST("check"),
132 .desc = "Health-check",
133 .arg_def = TRC_ARG1_CHK, // TRACE()'s first argument is always a stream
134 .default_cb = check_trace,
135 .known_events = check_trace_events,
136 .lockon_args = check_trace_lockon_args,
137 .decoding = check_trace_decoding,
138 .report_events = ~0, // report everything by default
139};
140
141#define TRACE_SOURCE &trace_check
142INITCALL1(STG_REGISTER, trace_register_source, TRACE_SOURCE);
143
Olivier Houchard9130a962017-10-17 17:33:43 +0200144
Christopher Faulet61cc8522020-04-20 14:54:42 +0200145static int wake_srv_chk(struct conn_stream *cs);
146struct data_cb check_conn_cb = {
147 .wake = wake_srv_chk,
148 .name = "CHCK",
149};
Christopher Fauletd7e63962020-04-17 20:15:59 +0200150
Christopher Faulet5d503fc2020-03-30 20:34:34 +0200151
Gaetan Rivet05d692d2020-02-14 17:42:54 +0100152/* Dummy frontend used to create all checks sessions. */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200153struct proxy checks_fe;
Christopher Faulet31dff9b2017-10-23 15:45:20 +0200154
Christopher Faulet147b8c92021-04-10 09:00:38 +0200155
156static inline void check_trace_buf(const struct buffer *buf, size_t ofs, size_t len)
157{
158 size_t block1, block2;
159 int line, ptr, newptr;
160
161 block1 = b_contig_data(buf, ofs);
162 block2 = 0;
163 if (block1 > len)
164 block1 = len;
165 block2 = len - block1;
166
167 ofs = b_peek_ofs(buf, ofs);
168
169 line = 0;
170 ptr = ofs;
171 while (ptr < ofs + block1) {
172 newptr = dump_text_line(&trace_buf, b_orig(buf), b_size(buf), ofs + block1, &line, ptr);
173 if (newptr == ptr)
174 break;
175 ptr = newptr;
176 }
177
178 line = ptr = 0;
179 while (ptr < block2) {
180 newptr = dump_text_line(&trace_buf, b_orig(buf), b_size(buf), block2, &line, ptr);
181 if (newptr == ptr)
182 break;
183 ptr = newptr;
184 }
185}
186
187/* trace source and events */
188static void check_trace(enum trace_level level, uint64_t mask,
189 const struct trace_source *src,
190 const struct ist where, const struct ist func,
191 const void *a1, const void *a2, const void *a3, const void *a4)
192{
193 const struct check *check = a1;
194 const struct server *srv = (check ? check->server : NULL);
195 const size_t *val = a4;
196 const char *res;
197
198 if (!check || src->verbosity < CHK_VERB_CLEAN)
199 return;
200
Christopher Faulet5f76c902022-06-08 09:12:58 +0200201 if (srv) {
202 chunk_appendf(&trace_buf, " : [%c] SRV=%s",
203 ((check->type == PR_O2_EXT_CHK) ? 'E' : (check->state & CHK_ST_AGENT ? 'A' : 'H')),
204 srv->id);
Christopher Faulet147b8c92021-04-10 09:00:38 +0200205
Christopher Faulet5f76c902022-06-08 09:12:58 +0200206 chunk_appendf(&trace_buf, " status=%d/%d %s",
207 (check->health >= check->rise) ? check->health - check->rise + 1 : check->health,
208 (check->health >= check->rise) ? check->fall : check->rise,
209 (check->health >= check->rise) ? (srv->uweight ? "UP" : "DRAIN") : "DOWN");
210 }
211 else
212 chunk_appendf(&trace_buf, " : [EMAIL]");
Christopher Faulet147b8c92021-04-10 09:00:38 +0200213
214 switch (check->result) {
215 case CHK_RES_NEUTRAL: res = "-"; break;
216 case CHK_RES_FAILED: res = "FAIL"; break;
217 case CHK_RES_PASSED: res = "PASS"; break;
218 case CHK_RES_CONDPASS: res = "COND"; break;
219 default: res = "UNK"; break;
220 }
221
222 if (src->verbosity == CHK_VERB_CLEAN)
223 return;
224
225 chunk_appendf(&trace_buf, " - last=%s(%d)/%s(%d)",
226 get_check_status_info(check->status), check->status,
227 res, check->result);
228
229 /* Display the value to the 4th argument (level > STATE) */
230 if (src->level > TRACE_LEVEL_STATE && val)
231 chunk_appendf(&trace_buf, " - VAL=%lu", (long)*val);
232
233 chunk_appendf(&trace_buf, " check=%p(0x%08x)", check, check->state);
234
235 if (src->verbosity == CHK_VERB_MINIMAL)
236 return;
237
238
239 if (check->cs) {
240 chunk_appendf(&trace_buf, " - conn=%p(0x%08x)", check->cs->conn, check->cs->conn->flags);
241 chunk_appendf(&trace_buf, " cs=%p(0x%08x)", check->cs, check->cs->flags);
242 }
243
244 if (mask & CHK_EV_TCPCHK) {
245 const char *type;
246
247 switch (check->tcpcheck_rules->flags & TCPCHK_RULES_PROTO_CHK) {
248 case TCPCHK_RULES_PGSQL_CHK: type = "PGSQL"; break;
249 case TCPCHK_RULES_REDIS_CHK: type = "REDIS"; break;
250 case TCPCHK_RULES_SMTP_CHK: type = "SMTP"; break;
251 case TCPCHK_RULES_HTTP_CHK: type = "HTTP"; break;
252 case TCPCHK_RULES_MYSQL_CHK: type = "MYSQL"; break;
253 case TCPCHK_RULES_LDAP_CHK: type = "LDAP"; break;
254 case TCPCHK_RULES_SSL3_CHK: type = "SSL3"; break;
255 case TCPCHK_RULES_AGENT_CHK: type = "AGENT"; break;
256 case TCPCHK_RULES_SPOP_CHK: type = "SPOP"; break;
257 case TCPCHK_RULES_TCP_CHK: type = "TCP"; break;
258 default: type = "???"; break;
259 }
260 if (check->current_step)
261 chunk_appendf(&trace_buf, " - tcp-check=(%s,%d)", type, tcpcheck_get_step_id(check, NULL));
262 else
263 chunk_appendf(&trace_buf, " - tcp-check=(%s,-)", type);
264 }
265
266 /* Display bi and bo buffer info (level > USER & verbosity > SIMPLE) */
267 if (src->level > TRACE_LEVEL_USER) {
268 const struct buffer *buf = NULL;
269
270 chunk_appendf(&trace_buf, " bi=%u@%p+%u/%u",
271 (unsigned int)b_data(&check->bi), b_orig(&check->bi),
272 (unsigned int)b_head_ofs(&check->bi), (unsigned int)b_size(&check->bi));
273 chunk_appendf(&trace_buf, " bo=%u@%p+%u/%u",
274 (unsigned int)b_data(&check->bo), b_orig(&check->bo),
275 (unsigned int)b_head_ofs(&check->bo), (unsigned int)b_size(&check->bo));
276
277 if (src->verbosity >= CHK_VERB_ADVANCED && (mask & (CHK_EV_RX)))
278 buf = (b_is_null(&check->bi) ? NULL : &check->bi);
279 else if (src->verbosity >= CHK_VERB_ADVANCED && (mask & (CHK_EV_TX)))
280 buf = (b_is_null(&check->bo) ? NULL : &check->bo);
281
282 if (buf) {
283 if ((check->tcpcheck_rules->flags & TCPCHK_RULES_PROTO_CHK) == TCPCHK_RULES_HTTP_CHK) {
284 int full = (src->verbosity == CHK_VERB_COMPLETE);
285
286 chunk_memcat(&trace_buf, "\n\t", 2);
287 htx_dump(&trace_buf, htxbuf(buf), full);
288 }
289 else {
290 int max = ((src->verbosity == CHK_VERB_COMPLETE) ? 1024 : 256);
291
292 chunk_memcat(&trace_buf, "\n", 1);
293 if (b_data(buf) > max) {
294 check_trace_buf(buf, 0, max);
295 chunk_memcat(&trace_buf, " ...\n", 6);
296 }
297 else
298 check_trace_buf(buf, 0, b_data(buf));
299 }
300
301 }
302 }
303
304}
305
306
Christopher Faulet61cc8522020-04-20 14:54:42 +0200307/**************************************************************************/
308/************************ Handle check results ****************************/
309/**************************************************************************/
310struct check_status {
311 short result; /* one of SRV_CHK_* */
312 char *info; /* human readable short info */
313 char *desc; /* long description */
314};
315
316struct analyze_status {
317 char *desc; /* description */
318 unsigned char lr[HANA_OBS_SIZE]; /* result for l4/l7: 0 = ignore, 1 - error, 2 - OK */
319};
320
Simon Horman63a4a822012-03-19 07:24:41 +0900321static const struct check_status check_statuses[HCHK_STATUS_SIZE] = {
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100322 [HCHK_STATUS_UNKNOWN] = { CHK_RES_UNKNOWN, "UNK", "Unknown" },
323 [HCHK_STATUS_INI] = { CHK_RES_UNKNOWN, "INI", "Initializing" },
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200324 [HCHK_STATUS_START] = { /* SPECIAL STATUS*/ },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200325
Willy Tarreau23964182014-05-20 20:56:30 +0200326 /* Below we have finished checks */
327 [HCHK_STATUS_CHECKED] = { CHK_RES_NEUTRAL, "CHECKED", "No status change" },
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100328 [HCHK_STATUS_HANA] = { CHK_RES_FAILED, "HANA", "Health analyze" },
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100329
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100330 [HCHK_STATUS_SOCKERR] = { CHK_RES_FAILED, "SOCKERR", "Socket error" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200331
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100332 [HCHK_STATUS_L4OK] = { CHK_RES_PASSED, "L4OK", "Layer4 check passed" },
333 [HCHK_STATUS_L4TOUT] = { CHK_RES_FAILED, "L4TOUT", "Layer4 timeout" },
334 [HCHK_STATUS_L4CON] = { CHK_RES_FAILED, "L4CON", "Layer4 connection problem" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200335
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100336 [HCHK_STATUS_L6OK] = { CHK_RES_PASSED, "L6OK", "Layer6 check passed" },
337 [HCHK_STATUS_L6TOUT] = { CHK_RES_FAILED, "L6TOUT", "Layer6 timeout" },
338 [HCHK_STATUS_L6RSP] = { CHK_RES_FAILED, "L6RSP", "Layer6 invalid response" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200339
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100340 [HCHK_STATUS_L7TOUT] = { CHK_RES_FAILED, "L7TOUT", "Layer7 timeout" },
341 [HCHK_STATUS_L7RSP] = { CHK_RES_FAILED, "L7RSP", "Layer7 invalid response" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200342
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200343 [HCHK_STATUS_L57DATA] = { /* DUMMY STATUS */ },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200344
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100345 [HCHK_STATUS_L7OKD] = { CHK_RES_PASSED, "L7OK", "Layer7 check passed" },
346 [HCHK_STATUS_L7OKCD] = { CHK_RES_CONDPASS, "L7OKC", "Layer7 check conditionally passed" },
347 [HCHK_STATUS_L7STS] = { CHK_RES_FAILED, "L7STS", "Layer7 wrong status" },
Simon Horman98637e52014-06-20 12:30:16 +0900348
349 [HCHK_STATUS_PROCERR] = { CHK_RES_FAILED, "PROCERR", "External check error" },
350 [HCHK_STATUS_PROCTOUT] = { CHK_RES_FAILED, "PROCTOUT", "External check timeout" },
Cyril Bonté77010d82014-08-07 01:55:37 +0200351 [HCHK_STATUS_PROCOK] = { CHK_RES_PASSED, "PROCOK", "External check passed" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200352};
353
Simon Horman63a4a822012-03-19 07:24:41 +0900354static const struct analyze_status analyze_statuses[HANA_STATUS_SIZE] = { /* 0: ignore, 1: error, 2: OK */
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100355 [HANA_STATUS_UNKNOWN] = { "Unknown", { 0, 0 }},
356
357 [HANA_STATUS_L4_OK] = { "L4 successful connection", { 2, 0 }},
358 [HANA_STATUS_L4_ERR] = { "L4 unsuccessful connection", { 1, 1 }},
359
360 [HANA_STATUS_HTTP_OK] = { "Correct http response", { 0, 2 }},
361 [HANA_STATUS_HTTP_STS] = { "Wrong http response", { 0, 1 }},
362 [HANA_STATUS_HTTP_HDRRSP] = { "Invalid http response (headers)", { 0, 1 }},
363 [HANA_STATUS_HTTP_RSP] = { "Invalid http response", { 0, 1 }},
364
365 [HANA_STATUS_HTTP_READ_ERROR] = { "Read error (http)", { 0, 1 }},
366 [HANA_STATUS_HTTP_READ_TIMEOUT] = { "Read timeout (http)", { 0, 1 }},
367 [HANA_STATUS_HTTP_BROKEN_PIPE] = { "Close from server (http)", { 0, 1 }},
368};
369
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100370/* checks if <err> is a real error for errno or one that can be ignored, and
371 * return 0 for these ones or <err> for real ones.
372 */
373static inline int unclean_errno(int err)
374{
375 if (err == EAGAIN || err == EINPROGRESS ||
376 err == EISCONN || err == EALREADY)
377 return 0;
378 return err;
379}
380
Christopher Faulet7aa32712021-02-01 13:11:50 +0100381/* Converts check_status code to result code */
382short get_check_status_result(short check_status)
383{
384 if (check_status < HCHK_STATUS_SIZE)
385 return check_statuses[check_status].result;
386 else
387 return check_statuses[HCHK_STATUS_UNKNOWN].result;
388}
389
Christopher Faulet61cc8522020-04-20 14:54:42 +0200390/* Converts check_status code to description */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200391const char *get_check_status_description(short check_status) {
392
393 const char *desc;
394
395 if (check_status < HCHK_STATUS_SIZE)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200396 desc = check_statuses[check_status].desc;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200397 else
398 desc = NULL;
399
400 if (desc && *desc)
401 return desc;
402 else
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200403 return check_statuses[HCHK_STATUS_UNKNOWN].desc;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200404}
405
Christopher Faulet61cc8522020-04-20 14:54:42 +0200406/* Converts check_status code to short info */
William Dauchyb26122b2021-02-14 22:26:23 +0100407const char *get_check_status_info(short check_status)
408{
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200409 const char *info;
410
411 if (check_status < HCHK_STATUS_SIZE)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200412 info = check_statuses[check_status].info;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200413 else
414 info = NULL;
415
416 if (info && *info)
417 return info;
418 else
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200419 return check_statuses[HCHK_STATUS_UNKNOWN].info;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200420}
421
Christopher Faulet61cc8522020-04-20 14:54:42 +0200422/* Convert analyze_status to description */
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100423const char *get_analyze_status(short analyze_status) {
424
425 const char *desc;
426
427 if (analyze_status < HANA_STATUS_SIZE)
428 desc = analyze_statuses[analyze_status].desc;
429 else
430 desc = NULL;
431
432 if (desc && *desc)
433 return desc;
434 else
435 return analyze_statuses[HANA_STATUS_UNKNOWN].desc;
436}
437
Christopher Faulet61cc8522020-04-20 14:54:42 +0200438/* Sets check->status, update check->duration and fill check->result with an
439 * adequate CHK_RES_* value. The new check->health is computed based on the
440 * result.
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200441 *
Christopher Faulet61cc8522020-04-20 14:54:42 +0200442 * Shows information in logs about failed health check if server is UP or
443 * succeeded health checks if server is DOWN.
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200444 */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200445void set_server_check_status(struct check *check, short status, const char *desc)
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100446{
Simon Horman4a741432013-02-23 15:35:38 +0900447 struct server *s = check->server;
Willy Tarreaubef1b322014-05-13 21:01:39 +0200448 short prev_status = check->status;
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200449 int report = 0;
Simon Horman4a741432013-02-23 15:35:38 +0900450
Christopher Faulet147b8c92021-04-10 09:00:38 +0200451 TRACE_POINT(CHK_EV_HCHK_RUN, check);
452
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200453 if (status == HCHK_STATUS_START) {
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100454 check->result = CHK_RES_UNKNOWN; /* no result yet */
Simon Horman4a741432013-02-23 15:35:38 +0900455 check->desc[0] = '\0';
456 check->start = now;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200457 return;
458 }
459
Simon Horman4a741432013-02-23 15:35:38 +0900460 if (!check->status)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200461 return;
462
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200463 if (desc && *desc) {
Simon Horman4a741432013-02-23 15:35:38 +0900464 strncpy(check->desc, desc, HCHK_DESC_LEN-1);
465 check->desc[HCHK_DESC_LEN-1] = '\0';
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200466 } else
Simon Horman4a741432013-02-23 15:35:38 +0900467 check->desc[0] = '\0';
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200468
Simon Horman4a741432013-02-23 15:35:38 +0900469 check->status = status;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200470 if (check_statuses[status].result)
Simon Horman4a741432013-02-23 15:35:38 +0900471 check->result = check_statuses[status].result;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200472
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100473 if (status == HCHK_STATUS_HANA)
Simon Horman4a741432013-02-23 15:35:38 +0900474 check->duration = -1;
475 else if (!tv_iszero(&check->start)) {
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200476 /* set_server_check_status() may be called more than once */
Simon Horman4a741432013-02-23 15:35:38 +0900477 check->duration = tv_ms_elapsed(&check->start, &now);
478 tv_zero(&check->start);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200479 }
480
Willy Tarreau23964182014-05-20 20:56:30 +0200481 /* no change is expected if no state change occurred */
482 if (check->result == CHK_RES_NEUTRAL)
483 return;
484
Olivier Houchard0923fa42019-01-11 18:43:04 +0100485 /* If the check was really just sending a mail, it won't have an
486 * associated server, so we're done now.
487 */
488 if (!s)
489 return;
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200490 report = 0;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200491
Christopher Faulet147b8c92021-04-10 09:00:38 +0200492
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200493 switch (check->result) {
494 case CHK_RES_FAILED:
Willy Tarreau12634e12014-05-23 11:32:36 +0200495 /* Failure to connect to the agent as a secondary check should not
496 * cause the server to be marked down.
497 */
498 if ((!(check->state & CHK_ST_AGENT) ||
Simon Hormaneaabd522015-02-26 11:26:17 +0900499 (check->status >= HCHK_STATUS_L57DATA)) &&
Christopher Fauletb119a792018-05-02 12:12:45 +0200500 (check->health > 0)) {
Willy Tarreau4781b152021-04-06 13:53:36 +0200501 _HA_ATOMIC_INC(&s->counters.failed_checks);
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200502 report = 1;
503 check->health--;
504 if (check->health < check->rise)
505 check->health = 0;
506 }
507 break;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200508
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200509 case CHK_RES_PASSED:
Christopher Faulet1e527cb2020-11-20 18:13:02 +0100510 case CHK_RES_CONDPASS:
511 if (check->health < check->rise + check->fall - 1) {
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200512 report = 1;
513 check->health++;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200514
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200515 if (check->health >= check->rise)
516 check->health = check->rise + check->fall - 1; /* OK now */
517 }
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200518
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200519 /* clear consecutive_errors if observing is enabled */
520 if (s->onerror)
521 s->consecutive_errors = 0;
522 break;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100523
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200524 default:
525 break;
526 }
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200527
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200528 if (s->proxy->options2 & PR_O2_LOGHCHKS &&
529 (status != prev_status || report)) {
530 chunk_printf(&trash,
Willy Tarreau12634e12014-05-23 11:32:36 +0200531 "%s check for %sserver %s/%s %s%s",
532 (check->state & CHK_ST_AGENT) ? "Agent" : "Health",
Willy Tarreauc93cd162014-05-13 15:54:22 +0200533 s->flags & SRV_F_BACKUP ? "backup " : "",
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100534 s->proxy->id, s->id,
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100535 (check->result == CHK_RES_CONDPASS) ? "conditionally ":"",
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200536 (check->result >= CHK_RES_PASSED) ? "succeeded" : "failed");
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200537
Emeric Brun5a133512017-10-19 14:42:30 +0200538 srv_append_status(&trash, s, check, -1, 0);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200539
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100540 chunk_appendf(&trash, ", status: %d/%d %s",
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200541 (check->health >= check->rise) ? check->health - check->rise + 1 : check->health,
542 (check->health >= check->rise) ? check->fall : check->rise,
543 (check->health >= check->rise) ? (s->uweight ? "UP" : "DRAIN") : "DOWN");
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200544
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200545 ha_warning("%s.\n", trash.area);
546 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
547 send_email_alert(s, LOG_INFO, "%s", trash.area);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200548 }
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200549}
550
Willy Tarreau4eec5472014-05-20 22:32:27 +0200551/* Marks the check <check>'s server down if the current check is already failed
552 * and the server is not down yet nor in maintenance.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200553 */
Willy Tarreaubcc67332020-06-05 15:31:31 +0200554void check_notify_failure(struct check *check)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200555{
Simon Horman4a741432013-02-23 15:35:38 +0900556 struct server *s = check->server;
Simon Hormane0d1bfb2011-06-21 14:34:58 +0900557
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200558 /* The agent secondary check should only cause a server to be marked
559 * as down if check->status is HCHK_STATUS_L7STS, which indicates
560 * that the agent returned "fail", "stopped" or "down".
561 * The implication here is that failure to connect to the agent
562 * as a secondary check should not cause the server to be marked
563 * down. */
564 if ((check->state & CHK_ST_AGENT) && check->status != HCHK_STATUS_L7STS)
565 return;
566
Willy Tarreau4eec5472014-05-20 22:32:27 +0200567 if (check->health > 0)
568 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100569
Christopher Faulet147b8c92021-04-10 09:00:38 +0200570 TRACE_STATE("health-check failed, set server DOWN", CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
Willy Tarreau4eec5472014-05-20 22:32:27 +0200571 /* We only report a reason for the check if we did not do so previously */
Emeric Brun5a133512017-10-19 14:42:30 +0200572 srv_set_stopped(s, NULL, (!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS)) ? check : NULL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200573}
574
Willy Tarreauaf549582014-05-16 17:37:50 +0200575/* Marks the check <check> as valid and tries to set its server up, provided
Willy Tarreau3e048382014-05-21 10:30:54 +0200576 * it isn't in maintenance, it is not tracking a down server and other checks
577 * comply. The rule is simple : by default, a server is up, unless any of the
578 * following conditions is true :
579 * - health check failed (check->health < rise)
580 * - agent check failed (agent->health < rise)
581 * - the server tracks a down server (track && track->state == STOPPED)
582 * Note that if the server has a slowstart, it will switch to STARTING instead
583 * of RUNNING. Also, only the health checks support the nolb mode, so the
584 * agent's success may not take the server out of this mode.
Willy Tarreauaf549582014-05-16 17:37:50 +0200585 */
Willy Tarreaubcc67332020-06-05 15:31:31 +0200586void check_notify_success(struct check *check)
Willy Tarreauaf549582014-05-16 17:37:50 +0200587{
Simon Horman4a741432013-02-23 15:35:38 +0900588 struct server *s = check->server;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100589
Emeric Brun52a91d32017-08-31 14:41:55 +0200590 if (s->next_admin & SRV_ADMF_MAINT)
Willy Tarreauaf549582014-05-16 17:37:50 +0200591 return;
Cyril Bontécd19e512010-01-31 22:34:03 +0100592
Emeric Brun52a91d32017-08-31 14:41:55 +0200593 if (s->track && s->track->next_state == SRV_ST_STOPPED)
Willy Tarreauaf549582014-05-16 17:37:50 +0200594 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100595
Willy Tarreau3e048382014-05-21 10:30:54 +0200596 if ((s->check.state & CHK_ST_ENABLED) && (s->check.health < s->check.rise))
597 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100598
Willy Tarreau3e048382014-05-21 10:30:54 +0200599 if ((s->agent.state & CHK_ST_ENABLED) && (s->agent.health < s->agent.rise))
600 return;
Willy Tarreauaf549582014-05-16 17:37:50 +0200601
Emeric Brun52a91d32017-08-31 14:41:55 +0200602 if ((check->state & CHK_ST_AGENT) && s->next_state == SRV_ST_STOPPING)
Willy Tarreau3e048382014-05-21 10:30:54 +0200603 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100604
Christopher Faulet147b8c92021-04-10 09:00:38 +0200605 TRACE_STATE("health-check succeeded, set server RUNNING", CHK_EV_HCHK_END|CHK_EV_HCHK_SUCC, check);
Emeric Brun5a133512017-10-19 14:42:30 +0200606 srv_set_running(s, NULL, (!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS)) ? check : NULL);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100607}
608
Willy Tarreaudb58b792014-05-21 13:57:23 +0200609/* Marks the check <check> as valid and tries to set its server into stopping mode
610 * if it was running or starting, and provided it isn't in maintenance and other
611 * checks comply. The conditions for the server to be marked in stopping mode are
612 * the same as for it to be turned up. Also, only the health checks support the
613 * nolb mode.
Willy Tarreauaf549582014-05-16 17:37:50 +0200614 */
Willy Tarreaubcc67332020-06-05 15:31:31 +0200615void check_notify_stopping(struct check *check)
Willy Tarreauaf549582014-05-16 17:37:50 +0200616{
Simon Horman4a741432013-02-23 15:35:38 +0900617 struct server *s = check->server;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100618
Emeric Brun52a91d32017-08-31 14:41:55 +0200619 if (s->next_admin & SRV_ADMF_MAINT)
Willy Tarreauaf549582014-05-16 17:37:50 +0200620 return;
621
Willy Tarreaudb58b792014-05-21 13:57:23 +0200622 if (check->state & CHK_ST_AGENT)
623 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100624
Emeric Brun52a91d32017-08-31 14:41:55 +0200625 if (s->track && s->track->next_state == SRV_ST_STOPPED)
Willy Tarreaudb58b792014-05-21 13:57:23 +0200626 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100627
Willy Tarreaudb58b792014-05-21 13:57:23 +0200628 if ((s->check.state & CHK_ST_ENABLED) && (s->check.health < s->check.rise))
629 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100630
Willy Tarreaudb58b792014-05-21 13:57:23 +0200631 if ((s->agent.state & CHK_ST_ENABLED) && (s->agent.health < s->agent.rise))
632 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100633
Christopher Faulet147b8c92021-04-10 09:00:38 +0200634 TRACE_STATE("health-check condionnaly succeeded, set server STOPPING", CHK_EV_HCHK_END|CHK_EV_HCHK_SUCC, check);
Willy Tarreaub26881a2017-12-23 11:16:49 +0100635 srv_set_stopping(s, NULL, (!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS)) ? check : NULL);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100636}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200637
Willy Tarreau9fe7aae2013-12-31 23:47:37 +0100638/* note: use health_adjust() only, which first checks that the observe mode is
Willy Tarreau4e9df272021-02-17 15:20:19 +0100639 * enabled. This will take the server lock if needed.
Willy Tarreau9fe7aae2013-12-31 23:47:37 +0100640 */
641void __health_adjust(struct server *s, short status)
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100642{
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100643 int failed;
644 int expire;
645
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100646 if (s->observe >= HANA_OBS_SIZE)
647 return;
648
Willy Tarreaubb956662013-01-24 00:37:39 +0100649 if (status >= HANA_STATUS_SIZE || !analyze_statuses[status].desc)
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100650 return;
651
652 switch (analyze_statuses[status].lr[s->observe - 1]) {
653 case 1:
654 failed = 1;
655 break;
656
657 case 2:
658 failed = 0;
659 break;
660
661 default:
662 return;
663 }
664
665 if (!failed) {
666 /* good: clear consecutive_errors */
667 s->consecutive_errors = 0;
668 return;
669 }
670
Willy Tarreau4781b152021-04-06 13:53:36 +0200671 _HA_ATOMIC_INC(&s->consecutive_errors);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100672
673 if (s->consecutive_errors < s->consecutive_errors_limit)
674 return;
675
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100676 chunk_printf(&trash, "Detected %d consecutive errors, last one was: %s",
677 s->consecutive_errors, get_analyze_status(status));
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100678
Willy Tarreau4e9df272021-02-17 15:20:19 +0100679 if (s->check.fastinter)
680 expire = tick_add(now_ms, MS_TO_TICKS(s->check.fastinter));
681 else
682 expire = TICK_ETERNITY;
683
684 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
685
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100686 switch (s->onerror) {
687 case HANA_ONERR_FASTINTER:
688 /* force fastinter - nothing to do here as all modes force it */
689 break;
690
691 case HANA_ONERR_SUDDTH:
692 /* simulate a pre-fatal failed health check */
Simon Horman58c32972013-11-25 10:46:38 +0900693 if (s->check.health > s->check.rise)
694 s->check.health = s->check.rise + 1;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100695
Tim Duesterhus588b3142020-05-29 14:35:51 +0200696 /* fall through */
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100697
698 case HANA_ONERR_FAILCHK:
699 /* simulate a failed health check */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200700 set_server_check_status(&s->check, HCHK_STATUS_HANA,
701 trash.area);
Willy Tarreau4eec5472014-05-20 22:32:27 +0200702 check_notify_failure(&s->check);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100703 break;
704
705 case HANA_ONERR_MARKDWN:
706 /* mark server down */
Simon Horman58c32972013-11-25 10:46:38 +0900707 s->check.health = s->check.rise;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200708 set_server_check_status(&s->check, HCHK_STATUS_HANA,
709 trash.area);
Willy Tarreau4eec5472014-05-20 22:32:27 +0200710 check_notify_failure(&s->check);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100711 break;
712
713 default:
714 /* write a warning? */
715 break;
716 }
717
Willy Tarreau4e9df272021-02-17 15:20:19 +0100718 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
719
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100720 s->consecutive_errors = 0;
Willy Tarreau4781b152021-04-06 13:53:36 +0200721 _HA_ATOMIC_INC(&s->counters.failed_hana);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100722
Christopher Fauletea860832021-05-07 11:45:26 +0200723 if (tick_isset(expire) && tick_is_lt(expire, s->check.task->expire)) {
Willy Tarreau4e9df272021-02-17 15:20:19 +0100724 /* requeue check task with new expire */
725 task_schedule(s->check.task, expire);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100726 }
Willy Tarreauef781042010-01-27 11:53:01 +0100727}
728
Christopher Faulet61cc8522020-04-20 14:54:42 +0200729/* Checks the connection. If an error has already been reported or the socket is
Willy Tarreau20a18342013-12-05 00:31:46 +0100730 * closed, keep errno intact as it is supposed to contain the valid error code.
731 * If no error is reported, check the socket's error queue using getsockopt().
732 * Warning, this must be done only once when returning from poll, and never
733 * after an I/O error was attempted, otherwise the error queue might contain
734 * inconsistent errors. If an error is detected, the CO_FL_ERROR is set on the
735 * socket. Returns non-zero if an error was reported, zero if everything is
736 * clean (including a properly closed socket).
737 */
738static int retrieve_errno_from_socket(struct connection *conn)
739{
740 int skerr;
741 socklen_t lskerr = sizeof(skerr);
742
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100743 if (conn->flags & CO_FL_ERROR && (unclean_errno(errno) || !conn->ctrl))
Willy Tarreau20a18342013-12-05 00:31:46 +0100744 return 1;
745
Willy Tarreau3c728722014-01-23 13:50:42 +0100746 if (!conn_ctrl_ready(conn))
Willy Tarreau20a18342013-12-05 00:31:46 +0100747 return 0;
748
Willy Tarreau585744b2017-08-24 14:31:19 +0200749 if (getsockopt(conn->handle.fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr) == 0)
Willy Tarreau20a18342013-12-05 00:31:46 +0100750 errno = skerr;
751
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100752 errno = unclean_errno(errno);
Willy Tarreau20a18342013-12-05 00:31:46 +0100753
754 if (!errno) {
755 /* we could not retrieve an error, that does not mean there is
756 * none. Just don't change anything and only report the prior
757 * error if any.
758 */
759 if (conn->flags & CO_FL_ERROR)
760 return 1;
761 else
762 return 0;
763 }
764
765 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_WR_SH | CO_FL_SOCK_RD_SH;
766 return 1;
767}
768
Christopher Faulet61cc8522020-04-20 14:54:42 +0200769/* Tries to collect as much information as possible on the connection status,
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100770 * and adjust the server status accordingly. It may make use of <errno_bck>
771 * if non-null when the caller is absolutely certain of its validity (eg:
772 * checked just after a syscall). If the caller doesn't have a valid errno,
773 * it can pass zero, and retrieve_errno_from_socket() will be called to try
774 * to extract errno from the socket. If no error is reported, it will consider
775 * the <expired> flag. This is intended to be used when a connection error was
776 * reported in conn->flags or when a timeout was reported in <expired>. The
777 * function takes care of not updating a server status which was already set.
778 * All situations where at least one of <expired> or CO_FL_ERROR are set
779 * produce a status.
780 */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200781void chk_report_conn_err(struct check *check, int errno_bck, int expired)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100782{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200783 struct conn_stream *cs = check->cs;
784 struct connection *conn = cs_conn(cs);
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100785 const char *err_msg;
Willy Tarreau83061a82018-07-13 11:56:34 +0200786 struct buffer *chk;
Willy Tarreau213c6782014-10-02 14:51:02 +0200787 int step;
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100788
Christopher Faulet147b8c92021-04-10 09:00:38 +0200789 if (check->result != CHK_RES_UNKNOWN) {
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100790 return;
Christopher Faulet147b8c92021-04-10 09:00:38 +0200791 }
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100792
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100793 errno = unclean_errno(errno_bck);
794 if (conn && errno)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100795 retrieve_errno_from_socket(conn);
796
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200797 if (conn && !(conn->flags & CO_FL_ERROR) &&
798 !(cs->flags & CS_FL_ERROR) && !expired)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100799 return;
800
Christopher Faulet147b8c92021-04-10 09:00:38 +0200801 TRACE_ENTER(CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check, 0, 0, (size_t[]){expired});
802
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100803 /* we'll try to build a meaningful error message depending on the
804 * context of the error possibly present in conn->err_code, and the
805 * socket error possibly collected above. This is useful to know the
806 * exact step of the L6 layer (eg: SSL handshake).
807 */
Baptiste Assmann5ecb77f2013-10-06 23:24:13 +0200808 chk = get_trash_chunk();
809
Christopher Faulet799f3a42020-04-07 12:06:14 +0200810 if (check->type == PR_O2_TCPCHK_CHK &&
Christopher Fauletd7e63962020-04-17 20:15:59 +0200811 (check->tcpcheck_rules->flags & TCPCHK_RULES_PROTO_CHK) == TCPCHK_RULES_TCP_CHK) {
Christopher Fauletb2c2e0f2020-03-30 11:05:10 +0200812 step = tcpcheck_get_step_id(check, NULL);
Christopher Faulet147b8c92021-04-10 09:00:38 +0200813 if (!step) {
814 TRACE_DEVEL("initial connection failure", CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
Willy Tarreau213c6782014-10-02 14:51:02 +0200815 chunk_printf(chk, " at initial connection step of tcp-check");
Christopher Faulet147b8c92021-04-10 09:00:38 +0200816 }
Willy Tarreau213c6782014-10-02 14:51:02 +0200817 else {
818 chunk_printf(chk, " at step %d of tcp-check", step);
819 /* we were looking for a string */
Christopher Fauletb2c2e0f2020-03-30 11:05:10 +0200820 if (check->current_step && check->current_step->action == TCPCHK_ACT_CONNECT) {
821 if (check->current_step->connect.port)
822 chunk_appendf(chk, " (connect port %d)" ,check->current_step->connect.port);
Willy Tarreau213c6782014-10-02 14:51:02 +0200823 else
824 chunk_appendf(chk, " (connect)");
Christopher Faulet147b8c92021-04-10 09:00:38 +0200825 TRACE_DEVEL("connection failure", CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
Willy Tarreau213c6782014-10-02 14:51:02 +0200826 }
Christopher Fauletb2c2e0f2020-03-30 11:05:10 +0200827 else if (check->current_step && check->current_step->action == TCPCHK_ACT_EXPECT) {
828 struct tcpcheck_expect *expect = &check->current_step->expect;
Gaetan Rivetb616add2020-02-07 15:37:17 +0100829
830 switch (expect->type) {
831 case TCPCHK_EXPECT_STRING:
Christopher Fauletb61caf42020-04-21 10:57:42 +0200832 chunk_appendf(chk, " (expect string '%.*s')", (unsigned int)istlen(expect->data), istptr(expect->data));
Gaetan Rivetb616add2020-02-07 15:37:17 +0100833 break;
834 case TCPCHK_EXPECT_BINARY:
Christopher Fauletb61caf42020-04-21 10:57:42 +0200835 chunk_appendf(chk, " (expect binary '%.*s')", (unsigned int)istlen(expect->data), istptr(expect->data));
Gaetan Rivetb616add2020-02-07 15:37:17 +0100836 break;
Christopher Faulet67a23452020-05-05 18:10:01 +0200837 case TCPCHK_EXPECT_STRING_REGEX:
Willy Tarreau213c6782014-10-02 14:51:02 +0200838 chunk_appendf(chk, " (expect regex)");
Gaetan Rivetb616add2020-02-07 15:37:17 +0100839 break;
Christopher Faulet67a23452020-05-05 18:10:01 +0200840 case TCPCHK_EXPECT_BINARY_REGEX:
Gaetan Rivetefab6c62020-02-07 15:37:17 +0100841 chunk_appendf(chk, " (expect binary regex)");
842 break;
Christopher Fauletaaab0832020-05-05 15:54:22 +0200843 case TCPCHK_EXPECT_STRING_LF:
844 chunk_appendf(chk, " (expect log-format string)");
845 break;
846 case TCPCHK_EXPECT_BINARY_LF:
847 chunk_appendf(chk, " (expect log-format binary)");
848 break;
Christopher Faulete5870d82020-04-15 11:32:03 +0200849 case TCPCHK_EXPECT_HTTP_STATUS:
Christopher Faulet8021a5f2020-04-24 13:53:12 +0200850 chunk_appendf(chk, " (expect HTTP status codes)");
Christopher Faulete5870d82020-04-15 11:32:03 +0200851 break;
Christopher Faulet67a23452020-05-05 18:10:01 +0200852 case TCPCHK_EXPECT_HTTP_STATUS_REGEX:
Christopher Faulete5870d82020-04-15 11:32:03 +0200853 chunk_appendf(chk, " (expect HTTP status regex)");
854 break;
Christopher Faulet39708192020-05-05 10:47:36 +0200855 case TCPCHK_EXPECT_HTTP_HEADER:
856 chunk_appendf(chk, " (expect HTTP header pattern)");
857 break;
Christopher Faulete5870d82020-04-15 11:32:03 +0200858 case TCPCHK_EXPECT_HTTP_BODY:
Christopher Fauletb61caf42020-04-21 10:57:42 +0200859 chunk_appendf(chk, " (expect HTTP body content '%.*s')", (unsigned int)istlen(expect->data), istptr(expect->data));
Christopher Faulete5870d82020-04-15 11:32:03 +0200860 break;
Christopher Faulet67a23452020-05-05 18:10:01 +0200861 case TCPCHK_EXPECT_HTTP_BODY_REGEX:
Christopher Faulete5870d82020-04-15 11:32:03 +0200862 chunk_appendf(chk, " (expect HTTP body regex)");
863 break;
Christopher Fauletaaab0832020-05-05 15:54:22 +0200864 case TCPCHK_EXPECT_HTTP_BODY_LF:
865 chunk_appendf(chk, " (expect log-format HTTP body)");
866 break;
Christopher Faulet9e6ed152020-04-03 15:24:06 +0200867 case TCPCHK_EXPECT_CUSTOM:
868 chunk_appendf(chk, " (expect custom function)");
869 break;
Gaetan Rivetb616add2020-02-07 15:37:17 +0100870 case TCPCHK_EXPECT_UNDEF:
871 chunk_appendf(chk, " (undefined expect!)");
872 break;
873 }
Christopher Faulet147b8c92021-04-10 09:00:38 +0200874 TRACE_DEVEL("expect rule failed", CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
Willy Tarreau213c6782014-10-02 14:51:02 +0200875 }
Christopher Fauletb2c2e0f2020-03-30 11:05:10 +0200876 else if (check->current_step && check->current_step->action == TCPCHK_ACT_SEND) {
Willy Tarreau213c6782014-10-02 14:51:02 +0200877 chunk_appendf(chk, " (send)");
Christopher Faulet147b8c92021-04-10 09:00:38 +0200878 TRACE_DEVEL("send rule failed", CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
Willy Tarreau213c6782014-10-02 14:51:02 +0200879 }
Baptiste Assmann22b09d22015-05-01 08:03:04 +0200880
Christopher Faulet6f2a5e42020-04-01 13:11:41 +0200881 if (check->current_step && check->current_step->comment)
882 chunk_appendf(chk, " comment: '%s'", check->current_step->comment);
Baptiste Assmann5ecb77f2013-10-06 23:24:13 +0200883 }
884 }
885
Willy Tarreau00149122017-10-04 18:05:01 +0200886 if (conn && conn->err_code) {
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100887 if (unclean_errno(errno))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200888 chunk_printf(&trash, "%s (%s)%s", conn_err_code_str(conn), strerror(errno),
889 chk->area);
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100890 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200891 chunk_printf(&trash, "%s%s", conn_err_code_str(conn),
892 chk->area);
893 err_msg = trash.area;
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100894 }
895 else {
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100896 if (unclean_errno(errno)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200897 chunk_printf(&trash, "%s%s", strerror(errno),
898 chk->area);
899 err_msg = trash.area;
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100900 }
901 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200902 err_msg = chk->area;
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100903 }
904 }
905
Willy Tarreau00149122017-10-04 18:05:01 +0200906 if (check->state & CHK_ST_PORT_MISS) {
Baptiste Assmann95db2bc2016-06-13 14:15:41 +0200907 /* NOTE: this is reported after <fall> tries */
Baptiste Assmann95db2bc2016-06-13 14:15:41 +0200908 set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
909 }
910
Christopher Faulet5e293762020-10-26 11:10:49 +0100911 if (!conn || !conn->ctrl) {
912 /* error before any connection attempt (connection allocation error or no control layer) */
Willy Tarreau00149122017-10-04 18:05:01 +0200913 set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
914 }
Willy Tarreauc192b0a2020-01-23 09:11:58 +0100915 else if (conn->flags & CO_FL_WAIT_L4_CONN) {
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100916 /* L4 not established (yet) */
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200917 if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100918 set_server_check_status(check, HCHK_STATUS_L4CON, err_msg);
919 else if (expired)
920 set_server_check_status(check, HCHK_STATUS_L4TOUT, err_msg);
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200921
922 /*
923 * might be due to a server IP change.
924 * Let's trigger a DNS resolution if none are currently running.
925 */
Olivier Houchard0923fa42019-01-11 18:43:04 +0100926 if (check->server)
Emeric Brund30e9a12020-12-23 18:49:16 +0100927 resolv_trigger_resolution(check->server->resolv_requester);
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200928
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100929 }
Willy Tarreauc192b0a2020-01-23 09:11:58 +0100930 else if (conn->flags & CO_FL_WAIT_L6_CONN) {
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100931 /* L6 not established (yet) */
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200932 if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100933 set_server_check_status(check, HCHK_STATUS_L6RSP, err_msg);
934 else if (expired)
935 set_server_check_status(check, HCHK_STATUS_L6TOUT, err_msg);
936 }
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200937 else if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR) {
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100938 /* I/O error after connection was established and before we could diagnose */
939 set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
940 }
941 else if (expired) {
Christopher Fauletcf80f2f2020-04-01 11:04:52 +0200942 enum healthcheck_status tout = HCHK_STATUS_L7TOUT;
943
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100944 /* connection established but expired check */
Christopher Faulet1941bab2020-05-05 07:55:50 +0200945 if (check->current_step && check->current_step->action == TCPCHK_ACT_EXPECT &&
946 check->current_step->expect.tout_status != HCHK_STATUS_UNKNOWN)
Christopher Faulet811f78c2020-04-01 11:10:27 +0200947 tout = check->current_step->expect.tout_status;
948 set_server_check_status(check, tout, err_msg);
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100949 }
950
Christopher Faulet147b8c92021-04-10 09:00:38 +0200951 TRACE_LEAVE(CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100952 return;
953}
954
Simon Horman98637e52014-06-20 12:30:16 +0900955
Christopher Faulet61cc8522020-04-20 14:54:42 +0200956/* Builds the server state header used by HTTP health-checks */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200957int httpchk_build_status_header(struct server *s, struct buffer *buf)
Simon Horman98637e52014-06-20 12:30:16 +0900958{
Christopher Faulet61cc8522020-04-20 14:54:42 +0200959 int sv_state;
960 int ratio;
961 char addr[46];
962 char port[6];
963 const char *srv_hlt_st[7] = { "DOWN", "DOWN %d/%d",
964 "UP %d/%d", "UP",
965 "NOLB %d/%d", "NOLB",
966 "no check" };
Simon Horman98637e52014-06-20 12:30:16 +0900967
Christopher Faulet61cc8522020-04-20 14:54:42 +0200968 if (!(s->check.state & CHK_ST_ENABLED))
969 sv_state = 6;
970 else if (s->cur_state != SRV_ST_STOPPED) {
971 if (s->check.health == s->check.rise + s->check.fall - 1)
972 sv_state = 3; /* UP */
973 else
974 sv_state = 2; /* going down */
Simon Horman98637e52014-06-20 12:30:16 +0900975
Christopher Faulet61cc8522020-04-20 14:54:42 +0200976 if (s->cur_state == SRV_ST_STOPPING)
977 sv_state += 2;
978 } else {
979 if (s->check.health)
980 sv_state = 1; /* going up */
981 else
982 sv_state = 0; /* DOWN */
Simon Horman98637e52014-06-20 12:30:16 +0900983 }
Willy Tarreaub7b24782016-06-21 15:32:29 +0200984
Christopher Faulet61cc8522020-04-20 14:54:42 +0200985 chunk_appendf(buf, srv_hlt_st[sv_state],
986 (s->cur_state != SRV_ST_STOPPED) ? (s->check.health - s->check.rise + 1) : (s->check.health),
987 (s->cur_state != SRV_ST_STOPPED) ? (s->check.fall) : (s->check.rise));
Willy Tarreaub7b24782016-06-21 15:32:29 +0200988
Christopher Faulet61cc8522020-04-20 14:54:42 +0200989 addr_to_str(&s->addr, addr, sizeof(addr));
990 if (s->addr.ss_family == AF_INET || s->addr.ss_family == AF_INET6)
991 snprintf(port, sizeof(port), "%u", s->svc_port);
992 else
993 *port = 0;
Willy Tarreaub7b24782016-06-21 15:32:29 +0200994
Christopher Faulet61cc8522020-04-20 14:54:42 +0200995 chunk_appendf(buf, "; address=%s; port=%s; name=%s/%s; node=%s; weight=%d/%d; scur=%d/%d; qcur=%d",
996 addr, port, s->proxy->id, s->id,
997 global.node,
998 (s->cur_eweight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv,
999 (s->proxy->lbprm.tot_weight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv,
1000 s->cur_sess, s->proxy->beconn - s->proxy->nbpend,
1001 s->nbpend);
Willy Tarreau9f6dc722019-03-01 11:15:10 +01001002
Christopher Faulet61cc8522020-04-20 14:54:42 +02001003 if ((s->cur_state == SRV_ST_STARTING) &&
1004 now.tv_sec < s->last_change + s->slowstart &&
1005 now.tv_sec >= s->last_change) {
1006 ratio = MAX(1, 100 * (now.tv_sec - s->last_change) / s->slowstart);
1007 chunk_appendf(buf, "; throttle=%d%%", ratio);
1008 }
Christopher Fauletaaae9a02020-04-26 09:50:31 +02001009
Christopher Faulet61cc8522020-04-20 14:54:42 +02001010 return b_data(buf);
1011}
Christopher Fauletaaae9a02020-04-26 09:50:31 +02001012
Willy Tarreau51cd5952020-06-05 12:25:38 +02001013/**************************************************************************/
Willy Tarreau51cd5952020-06-05 12:25:38 +02001014/***************** Health-checks based on connections *********************/
1015/**************************************************************************/
1016/* This function is used only for server health-checks. It handles connection
1017 * status updates including errors. If necessary, it wakes the check task up.
1018 * It returns 0 on normal cases, <0 if at least one close() has happened on the
1019 * connection (eg: reconnect). It relies on tcpcheck_main().
Christopher Faulet61cc8522020-04-20 14:54:42 +02001020 */
Willy Tarreau51cd5952020-06-05 12:25:38 +02001021static int wake_srv_chk(struct conn_stream *cs)
Christopher Faulet61cc8522020-04-20 14:54:42 +02001022{
Willy Tarreau51cd5952020-06-05 12:25:38 +02001023 struct connection *conn = cs->conn;
1024 struct check *check = cs->data;
1025 struct email_alertq *q = container_of(check, typeof(*q), check);
1026 int ret = 0;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001027
Christopher Faulet147b8c92021-04-10 09:00:38 +02001028 TRACE_ENTER(CHK_EV_HCHK_WAKE, check);
Willy Tarreau51cd5952020-06-05 12:25:38 +02001029 if (check->server)
1030 HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
1031 else
1032 HA_SPIN_LOCK(EMAIL_ALERTS_LOCK, &q->lock);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001033
Willy Tarreau51cd5952020-06-05 12:25:38 +02001034 /* we may have to make progress on the TCP checks */
1035 ret = tcpcheck_main(check);
Christopher Fauletaaab0832020-05-05 15:54:22 +02001036
Willy Tarreau51cd5952020-06-05 12:25:38 +02001037 cs = check->cs;
1038 conn = cs->conn;
Christopher Fauletaaab0832020-05-05 15:54:22 +02001039
Willy Tarreau51cd5952020-06-05 12:25:38 +02001040 if (unlikely(conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)) {
1041 /* We may get error reports bypassing the I/O handlers, typically
1042 * the case when sending a pure TCP check which fails, then the I/O
1043 * handlers above are not called. This is completely handled by the
1044 * main processing task so let's simply wake it up. If we get here,
1045 * we expect errno to still be valid.
1046 */
Christopher Faulet147b8c92021-04-10 09:00:38 +02001047 TRACE_ERROR("report connection error", CHK_EV_HCHK_WAKE|CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
Willy Tarreau51cd5952020-06-05 12:25:38 +02001048 chk_report_conn_err(check, errno, 0);
1049 task_wakeup(check->task, TASK_WOKEN_IO);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001050 }
1051
Christopher Faulet8f100422021-01-18 15:47:03 +01001052 if (check->result != CHK_RES_UNKNOWN || ret == -1) {
Willy Tarreau51cd5952020-06-05 12:25:38 +02001053 /* Check complete or aborted. If connection not yet closed do it
1054 * now and wake the check task up to be sure the result is
1055 * handled ASAP. */
Willy Tarreau30bd4ef2020-12-11 11:09:29 +01001056 cs_drain_and_close(cs);
Willy Tarreau51cd5952020-06-05 12:25:38 +02001057 ret = -1;
Christopher Faulet8f100422021-01-18 15:47:03 +01001058
1059 if (check->wait_list.events)
1060 cs->conn->mux->unsubscribe(cs, check->wait_list.events, &check->wait_list);
1061
Willy Tarreau51cd5952020-06-05 12:25:38 +02001062 /* We may have been scheduled to run, and the
1063 * I/O handler expects to have a cs, so remove
1064 * the tasklet
1065 */
1066 tasklet_remove_from_tasklet_list(check->wait_list.tasklet);
1067 task_wakeup(check->task, TASK_WOKEN_IO);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001068 }
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001069
Willy Tarreau51cd5952020-06-05 12:25:38 +02001070 if (check->server)
1071 HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
1072 else
1073 HA_SPIN_UNLOCK(EMAIL_ALERTS_LOCK, &q->lock);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001074
Christopher Faulet147b8c92021-04-10 09:00:38 +02001075 TRACE_LEAVE(CHK_EV_HCHK_WAKE, check);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001076 return ret;
1077}
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001078
Willy Tarreau51cd5952020-06-05 12:25:38 +02001079/* This function checks if any I/O is wanted, and if so, attempts to do so */
Willy Tarreau144f84a2021-03-02 16:09:26 +01001080struct task *event_srv_chk_io(struct task *t, void *ctx, unsigned int state)
Christopher Faulet61cc8522020-04-20 14:54:42 +02001081{
Willy Tarreau51cd5952020-06-05 12:25:38 +02001082 struct check *check = ctx;
1083 struct conn_stream *cs = check->cs;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001084
Willy Tarreau51cd5952020-06-05 12:25:38 +02001085 wake_srv_chk(cs);
1086 return NULL;
Christopher Faulet61cc8522020-04-20 14:54:42 +02001087}
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001088
Willy Tarreau51cd5952020-06-05 12:25:38 +02001089/* manages a server health-check that uses a connection. Returns
1090 * the time the task accepts to wait, or TIME_ETERNITY for infinity.
Christopher Faulet61cc8522020-04-20 14:54:42 +02001091 *
1092 * Please do NOT place any return statement in this function and only leave
Willy Tarreau51cd5952020-06-05 12:25:38 +02001093 * via the out_unlock label.
Christopher Faulet61cc8522020-04-20 14:54:42 +02001094 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01001095struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
Christopher Faulet61cc8522020-04-20 14:54:42 +02001096{
Willy Tarreau51cd5952020-06-05 12:25:38 +02001097 struct check *check = context;
1098 struct proxy *proxy = check->proxy;
Christopher Faulet92017a32021-05-06 16:01:18 +02001099 struct conn_stream *cs;
1100 struct connection *conn;
Willy Tarreau51cd5952020-06-05 12:25:38 +02001101 int rv;
1102 int expired = tick_is_expired(t->expire, now_ms);
Willy Tarreaudeccd112018-06-14 18:38:55 +02001103
Christopher Faulet147b8c92021-04-10 09:00:38 +02001104 TRACE_ENTER(CHK_EV_TASK_WAKE, check);
1105
Willy Tarreau51cd5952020-06-05 12:25:38 +02001106 if (check->server)
1107 HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
Christopher Faulet92017a32021-05-06 16:01:18 +02001108
Willy Tarreau51cd5952020-06-05 12:25:38 +02001109 if (!(check->state & CHK_ST_INPROGRESS)) {
1110 /* no check currently running */
Christopher Faulet147b8c92021-04-10 09:00:38 +02001111 if (!expired) /* woke up too early */ {
1112 TRACE_STATE("health-check wake up too early", CHK_EV_TASK_WAKE, check);
Willy Tarreau51cd5952020-06-05 12:25:38 +02001113 goto out_unlock;
Christopher Faulet147b8c92021-04-10 09:00:38 +02001114 }
Willy Tarreauabca5b62013-12-06 14:19:25 +01001115
Willy Tarreau51cd5952020-06-05 12:25:38 +02001116 /* we don't send any health-checks when the proxy is
1117 * stopped, the server should not be checked or the check
1118 * is disabled.
1119 */
1120 if (((check->state & (CHK_ST_ENABLED | CHK_ST_PAUSED)) != CHK_ST_ENABLED) ||
Christopher Faulet147b8c92021-04-10 09:00:38 +02001121 proxy->disabled) {
1122 TRACE_STATE("health-check paused or disabled", CHK_EV_TASK_WAKE, check);
Willy Tarreau51cd5952020-06-05 12:25:38 +02001123 goto reschedule;
Christopher Faulet147b8c92021-04-10 09:00:38 +02001124 }
Christopher Faulet404f9192020-04-09 23:13:54 +02001125
Willy Tarreau51cd5952020-06-05 12:25:38 +02001126 /* we'll initiate a new check */
1127 set_server_check_status(check, HCHK_STATUS_START, NULL);
Christopher Faulet404f9192020-04-09 23:13:54 +02001128
Willy Tarreau51cd5952020-06-05 12:25:38 +02001129 check->state |= CHK_ST_INPROGRESS;
Christopher Faulet147b8c92021-04-10 09:00:38 +02001130 TRACE_STATE("init new health-check", CHK_EV_TASK_WAKE|CHK_EV_HCHK_START, check);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001131
Willy Tarreau51cd5952020-06-05 12:25:38 +02001132 task_set_affinity(t, tid_bit);
1133
1134 check->current_step = NULL;
1135 tcpcheck_main(check);
Christopher Faulet92017a32021-05-06 16:01:18 +02001136 expired = 0;
Christopher Faulet61cc8522020-04-20 14:54:42 +02001137 }
Christopher Faulet92017a32021-05-06 16:01:18 +02001138
1139 cs = check->cs;
1140 conn = cs_conn(cs);
1141
1142 /* there was a test running.
1143 * First, let's check whether there was an uncaught error,
1144 * which can happen on connect timeout or error.
1145 */
1146 if (check->result == CHK_RES_UNKNOWN) {
1147 /* Here the connection must be defined. Otherwise the
1148 * error would have already been detected
Willy Tarreau51cd5952020-06-05 12:25:38 +02001149 */
Christopher Faulet92017a32021-05-06 16:01:18 +02001150 if ((conn && ((conn->flags & CO_FL_ERROR) || (cs->flags & CS_FL_ERROR))) || expired) {
1151 TRACE_ERROR("report connection error", CHK_EV_TASK_WAKE|CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
1152 chk_report_conn_err(check, 0, expired);
1153 }
1154 else {
1155 if (check->state & CHK_ST_CLOSE_CONN) {
1156 TRACE_DEVEL("closing current connection", CHK_EV_TASK_WAKE|CHK_EV_HCHK_RUN, check);
1157 cs_destroy(cs);
1158 cs = NULL;
1159 conn = NULL;
1160 check->cs = NULL;
1161 check->state &= ~CHK_ST_CLOSE_CONN;
1162 tcpcheck_main(check);
Willy Tarreau51cd5952020-06-05 12:25:38 +02001163 }
Christopher Faulet92017a32021-05-06 16:01:18 +02001164 if (check->result == CHK_RES_UNKNOWN) {
1165 TRACE_DEVEL("health-check not expired", CHK_EV_TASK_WAKE|CHK_EV_HCHK_RUN, check);
1166 goto out_unlock; /* timeout not reached, wait again */
Christopher Faulet8f100422021-01-18 15:47:03 +01001167 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001168 }
Christopher Faulet92017a32021-05-06 16:01:18 +02001169 }
Christopher Faulet404f9192020-04-09 23:13:54 +02001170
Christopher Faulet92017a32021-05-06 16:01:18 +02001171 /* check complete or aborted */
1172 TRACE_STATE("health-check complete or aborted", CHK_EV_TASK_WAKE|CHK_EV_HCHK_END, check);
Christopher Fauletba3c68f2020-04-01 16:27:05 +02001173
Christopher Faulet92017a32021-05-06 16:01:18 +02001174 check->current_step = NULL;
Christopher Fauletba3c68f2020-04-01 16:27:05 +02001175
Christopher Faulet92017a32021-05-06 16:01:18 +02001176 if (conn && conn->xprt) {
1177 /* The check was aborted and the connection was not yet closed.
1178 * This can happen upon timeout, or when an external event such
1179 * as a failed response coupled with "observe layer7" caused the
1180 * server state to be suddenly changed.
1181 */
1182 cs_drain_and_close(cs);
1183 }
Christopher Fauletba3c68f2020-04-01 16:27:05 +02001184
Christopher Faulet92017a32021-05-06 16:01:18 +02001185 if (cs) {
1186 if (check->wait_list.events)
1187 cs->conn->mux->unsubscribe(cs, check->wait_list.events, &check->wait_list);
1188 /* We may have been scheduled to run, and the
1189 * I/O handler expects to have a cs, so remove
1190 * the tasklet
1191 */
1192 tasklet_remove_from_tasklet_list(check->wait_list.tasklet);
1193 cs_destroy(cs);
1194 cs = check->cs = NULL;
1195 conn = NULL;
1196 }
Willy Tarreau51cd5952020-06-05 12:25:38 +02001197
Christopher Faulet92017a32021-05-06 16:01:18 +02001198 if (check->sess != NULL) {
1199 vars_prune(&check->vars, check->sess, NULL);
1200 session_free(check->sess);
1201 check->sess = NULL;
1202 }
Willy Tarreau51cd5952020-06-05 12:25:38 +02001203
Christopher Faulet92017a32021-05-06 16:01:18 +02001204 if (check->server) {
1205 if (check->result == CHK_RES_FAILED) {
1206 /* a failure or timeout detected */
1207 TRACE_DEVEL("report failure", CHK_EV_TASK_WAKE|CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
1208 check_notify_failure(check);
1209 }
1210 else if (check->result == CHK_RES_CONDPASS) {
1211 /* check is OK but asks for stopping mode */
1212 TRACE_DEVEL("report conditional success", CHK_EV_TASK_WAKE|CHK_EV_HCHK_END|CHK_EV_HCHK_SUCC, check);
1213 check_notify_stopping(check);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001214 }
Christopher Faulet92017a32021-05-06 16:01:18 +02001215 else if (check->result == CHK_RES_PASSED) {
1216 /* a success was detected */
1217 TRACE_DEVEL("report success", CHK_EV_TASK_WAKE|CHK_EV_HCHK_END|CHK_EV_HCHK_SUCC, check);
1218 check_notify_success(check);
1219 }
1220 }
Christopher Fauletecc34262022-05-18 14:24:43 +02001221
1222 if (LIST_INLIST(&check->buf_wait.list))
1223 LIST_DEL_INIT(&check->buf_wait.list);
1224
Christopher Faulet92017a32021-05-06 16:01:18 +02001225 task_set_affinity(t, MAX_THREADS_MASK);
1226 check_release_buf(check, &check->bi);
1227 check_release_buf(check, &check->bo);
1228 check->state &= ~(CHK_ST_INPROGRESS|CHK_ST_IN_ALLOC|CHK_ST_OUT_ALLOC);
Christopher Fauletba3c68f2020-04-01 16:27:05 +02001229
Christopher Faulet92017a32021-05-06 16:01:18 +02001230 if (check->server) {
1231 rv = 0;
1232 if (global.spread_checks > 0) {
1233 rv = srv_getinter(check) * global.spread_checks / 100;
1234 rv -= (int) (2 * rv * (ha_random32() / 4294967295.0));
Christopher Faulet61cc8522020-04-20 14:54:42 +02001235 }
Christopher Faulet92017a32021-05-06 16:01:18 +02001236 t->expire = tick_add(now_ms, MS_TO_TICKS(srv_getinter(check) + rv));
Christopher Faulet61cc8522020-04-20 14:54:42 +02001237 }
Willy Tarreau51cd5952020-06-05 12:25:38 +02001238
1239 reschedule:
1240 while (tick_is_expired(t->expire, now_ms))
1241 t->expire = tick_add(t->expire, MS_TO_TICKS(check->inter));
1242 out_unlock:
1243 if (check->server)
1244 HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
Christopher Faulet147b8c92021-04-10 09:00:38 +02001245
1246 TRACE_LEAVE(CHK_EV_TASK_WAKE, check);
Willy Tarreau51cd5952020-06-05 12:25:38 +02001247 return t;
Christopher Fauletba3c68f2020-04-01 16:27:05 +02001248}
1249
Willy Tarreau51cd5952020-06-05 12:25:38 +02001250
Christopher Faulet61cc8522020-04-20 14:54:42 +02001251/**************************************************************************/
1252/************************** Init/deinit checks ****************************/
1253/**************************************************************************/
Christopher Fauletb381a502020-11-25 13:47:00 +01001254/*
1255 * Tries to grab a buffer and to re-enables processing on check <target>. The
1256 * check flags are used to figure what buffer was requested. It returns 1 if the
1257 * allocation succeeds, in which case the I/O tasklet is woken up, or 0 if it's
1258 * impossible to wake up and we prefer to be woken up later.
1259 */
1260int check_buf_available(void *target)
Christopher Faulet61cc8522020-04-20 14:54:42 +02001261{
Christopher Fauletb381a502020-11-25 13:47:00 +01001262 struct check *check = target;
1263
Willy Tarreaud68d4f12021-03-22 14:44:31 +01001264 if ((check->state & CHK_ST_IN_ALLOC) && b_alloc(&check->bi)) {
Christopher Faulet147b8c92021-04-10 09:00:38 +02001265 TRACE_STATE("unblocking check, input buffer allocated", CHK_EV_TCPCHK_EXP|CHK_EV_RX_BLK, check);
Christopher Fauletb381a502020-11-25 13:47:00 +01001266 check->state &= ~CHK_ST_IN_ALLOC;
1267 tasklet_wakeup(check->wait_list.tasklet);
1268 return 1;
1269 }
Willy Tarreaud68d4f12021-03-22 14:44:31 +01001270 if ((check->state & CHK_ST_OUT_ALLOC) && b_alloc(&check->bo)) {
Christopher Faulet147b8c92021-04-10 09:00:38 +02001271 TRACE_STATE("unblocking check, output buffer allocated", CHK_EV_TCPCHK_SND|CHK_EV_TX_BLK, check);
Christopher Fauletb381a502020-11-25 13:47:00 +01001272 check->state &= ~CHK_ST_OUT_ALLOC;
1273 tasklet_wakeup(check->wait_list.tasklet);
1274 return 1;
1275 }
1276
1277 return 0;
1278}
Christopher Fauletba3c68f2020-04-01 16:27:05 +02001279
Christopher Fauletb381a502020-11-25 13:47:00 +01001280/*
William Dauchyf4300902021-02-06 20:47:50 +01001281 * Allocate a buffer. If it fails, it adds the check in buffer wait queue.
Christopher Fauletb381a502020-11-25 13:47:00 +01001282 */
1283struct buffer *check_get_buf(struct check *check, struct buffer *bptr)
1284{
1285 struct buffer *buf = NULL;
Christopher Fauletba3c68f2020-04-01 16:27:05 +02001286
Willy Tarreau2b718102021-04-21 07:32:39 +02001287 if (likely(!LIST_INLIST(&check->buf_wait.list)) &&
Willy Tarreaud68d4f12021-03-22 14:44:31 +01001288 unlikely((buf = b_alloc(bptr)) == NULL)) {
Christopher Fauletb381a502020-11-25 13:47:00 +01001289 check->buf_wait.target = check;
1290 check->buf_wait.wakeup_cb = check_buf_available;
Willy Tarreau2b718102021-04-21 07:32:39 +02001291 LIST_APPEND(&ti->buffer_wq, &check->buf_wait.list);
Christopher Fauletb381a502020-11-25 13:47:00 +01001292 }
1293 return buf;
1294}
1295
1296/*
1297 * Release a buffer, if any, and try to wake up entities waiting in the buffer
1298 * wait queue.
1299 */
1300void check_release_buf(struct check *check, struct buffer *bptr)
1301{
1302 if (bptr->size) {
1303 b_free(bptr);
Willy Tarreau4d77bbf2021-02-20 12:02:46 +01001304 offer_buffers(check->buf_wait.target, 1);
Christopher Fauletb381a502020-11-25 13:47:00 +01001305 }
1306}
1307
1308const char *init_check(struct check *check, int type)
1309{
1310 check->type = type;
Christopher Fauletba3c68f2020-04-01 16:27:05 +02001311
Christopher Fauletb381a502020-11-25 13:47:00 +01001312 check->bi = BUF_NULL;
1313 check->bo = BUF_NULL;
Willy Tarreau90f366b2021-02-20 11:49:49 +01001314 LIST_INIT(&check->buf_wait.list);
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001315
Christopher Faulet61cc8522020-04-20 14:54:42 +02001316 check->wait_list.tasklet = tasklet_new();
1317 if (!check->wait_list.tasklet)
1318 return "out of memory while allocating check tasklet";
1319 check->wait_list.events = 0;
1320 check->wait_list.tasklet->process = event_srv_chk_io;
1321 check->wait_list.tasklet->context = check;
1322 return NULL;
1323}
1324
1325void free_check(struct check *check)
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001326{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001327 task_destroy(check->task);
1328 if (check->wait_list.tasklet)
1329 tasklet_free(check->wait_list.tasklet);
1330
Christopher Fauletb381a502020-11-25 13:47:00 +01001331 check_release_buf(check, &check->bi);
1332 check_release_buf(check, &check->bo);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001333 if (check->cs) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001334 ha_free(&check->cs->conn);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001335 cs_free(check->cs);
1336 check->cs = NULL;
1337 }
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001338}
1339
Christopher Faulet61cc8522020-04-20 14:54:42 +02001340/* manages a server health-check. Returns the time the task accepts to wait, or
1341 * TIME_ETERNITY for infinity.
1342 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01001343struct task *process_chk(struct task *t, void *context, unsigned int state)
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001344{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001345 struct check *check = context;
1346
1347 if (check->type == PR_O2_EXT_CHK)
1348 return process_chk_proc(t, context, state);
1349 return process_chk_conn(t, context, state);
1350
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001351}
1352
Christopher Faulet61cc8522020-04-20 14:54:42 +02001353
1354static int start_check_task(struct check *check, int mininter,
1355 int nbcheck, int srvpos)
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001356{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001357 struct task *t;
1358 unsigned long thread_mask = MAX_THREADS_MASK;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001359
Christopher Faulet61cc8522020-04-20 14:54:42 +02001360 if (check->type == PR_O2_EXT_CHK)
1361 thread_mask = 1;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001362
Christopher Faulet61cc8522020-04-20 14:54:42 +02001363 /* task for the check */
1364 if ((t = task_new(thread_mask)) == NULL) {
1365 ha_alert("Starting [%s:%s] check: out of memory.\n",
1366 check->server->proxy->id, check->server->id);
1367 return 0;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001368 }
1369
Christopher Faulet61cc8522020-04-20 14:54:42 +02001370 check->task = t;
1371 t->process = process_chk;
1372 t->context = check;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001373
Christopher Faulet61cc8522020-04-20 14:54:42 +02001374 if (mininter < srv_getinter(check))
1375 mininter = srv_getinter(check);
1376
1377 if (global.max_spread_checks && mininter > global.max_spread_checks)
1378 mininter = global.max_spread_checks;
1379
1380 /* check this every ms */
1381 t->expire = tick_add(now_ms, MS_TO_TICKS(mininter * srvpos / nbcheck));
1382 check->start = now;
1383 task_queue(t);
1384
1385 return 1;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001386}
1387
Christopher Faulet61cc8522020-04-20 14:54:42 +02001388/* updates the server's weight during a warmup stage. Once the final weight is
1389 * reached, the task automatically stops. Note that any server status change
1390 * must have updated s->last_change accordingly.
1391 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01001392struct task *server_warmup(struct task *t, void *context, unsigned int state)
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001393{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001394 struct server *s = context;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001395
Christopher Faulet61cc8522020-04-20 14:54:42 +02001396 /* by default, plan on stopping the task */
1397 t->expire = TICK_ETERNITY;
1398 if ((s->next_admin & SRV_ADMF_MAINT) ||
1399 (s->next_state != SRV_ST_STARTING))
1400 return t;
Christopher Faulete5870d82020-04-15 11:32:03 +02001401
Christopher Faulet61cc8522020-04-20 14:54:42 +02001402 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001403
Christopher Faulet61cc8522020-04-20 14:54:42 +02001404 /* recalculate the weights and update the state */
1405 server_recalc_eweight(s, 1);
Christopher Faulet5c288742020-03-31 08:15:58 +02001406
Christopher Faulet61cc8522020-04-20 14:54:42 +02001407 /* probably that we can refill this server with a bit more connections */
1408 pendconn_grab_from_px(s);
Christopher Faulet5c288742020-03-31 08:15:58 +02001409
Christopher Faulet61cc8522020-04-20 14:54:42 +02001410 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Christopher Faulet5c288742020-03-31 08:15:58 +02001411
Christopher Faulet61cc8522020-04-20 14:54:42 +02001412 /* get back there in 1 second or 1/20th of the slowstart interval,
1413 * whichever is greater, resulting in small 5% steps.
1414 */
1415 if (s->next_state == SRV_ST_STARTING)
1416 t->expire = tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20)));
1417 return t;
1418}
1419
1420/*
1421 * Start health-check.
1422 * Returns 0 if OK, ERR_FATAL on error, and prints the error in this case.
1423 */
1424static int start_checks()
1425{
1426
1427 struct proxy *px;
1428 struct server *s;
1429 struct task *t;
1430 int nbcheck=0, mininter=0, srvpos=0;
1431
1432 /* 0- init the dummy frontend used to create all checks sessions */
1433 init_new_proxy(&checks_fe);
Christopher Faulet0f1fc232021-04-16 10:49:07 +02001434 checks_fe.id = strdup("CHECKS-FE");
Christopher Faulet61cc8522020-04-20 14:54:42 +02001435 checks_fe.cap = PR_CAP_FE | PR_CAP_BE;
1436 checks_fe.mode = PR_MODE_TCP;
1437 checks_fe.maxconn = 0;
1438 checks_fe.conn_retries = CONN_RETRIES;
1439 checks_fe.options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
1440 checks_fe.timeout.client = TICK_ETERNITY;
1441
1442 /* 1- count the checkers to run simultaneously.
1443 * We also determine the minimum interval among all of those which
1444 * have an interval larger than SRV_CHK_INTER_THRES. This interval
1445 * will be used to spread their start-up date. Those which have
1446 * a shorter interval will start independently and will not dictate
1447 * too short an interval for all others.
1448 */
1449 for (px = proxies_list; px; px = px->next) {
1450 for (s = px->srv; s; s = s->next) {
1451 if (s->slowstart) {
1452 if ((t = task_new(MAX_THREADS_MASK)) == NULL) {
1453 ha_alert("Starting [%s:%s] check: out of memory.\n", px->id, s->id);
1454 return ERR_ALERT | ERR_FATAL;
1455 }
1456 /* We need a warmup task that will be called when the server
1457 * state switches from down to up.
1458 */
1459 s->warmup = t;
1460 t->process = server_warmup;
1461 t->context = s;
1462 /* server can be in this state only because of */
1463 if (s->next_state == SRV_ST_STARTING)
1464 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, (now.tv_sec - s->last_change)) / 20)));
Christopher Faulet5c288742020-03-31 08:15:58 +02001465 }
1466
Christopher Faulet61cc8522020-04-20 14:54:42 +02001467 if (s->check.state & CHK_ST_CONFIGURED) {
1468 nbcheck++;
1469 if ((srv_getinter(&s->check) >= SRV_CHK_INTER_THRES) &&
1470 (!mininter || mininter > srv_getinter(&s->check)))
1471 mininter = srv_getinter(&s->check);
Christopher Faulet5c288742020-03-31 08:15:58 +02001472 }
1473
Christopher Faulet61cc8522020-04-20 14:54:42 +02001474 if (s->agent.state & CHK_ST_CONFIGURED) {
1475 nbcheck++;
1476 if ((srv_getinter(&s->agent) >= SRV_CHK_INTER_THRES) &&
1477 (!mininter || mininter > srv_getinter(&s->agent)))
1478 mininter = srv_getinter(&s->agent);
1479 }
Christopher Faulet5c288742020-03-31 08:15:58 +02001480 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001481 }
Christopher Fauletb7d30092020-03-30 15:19:03 +02001482
Christopher Faulet61cc8522020-04-20 14:54:42 +02001483 if (!nbcheck)
Christopher Fauletfc633b62020-11-06 15:24:23 +01001484 return ERR_NONE;
Christopher Fauletb7d30092020-03-30 15:19:03 +02001485
Christopher Faulet61cc8522020-04-20 14:54:42 +02001486 srand((unsigned)time(NULL));
Christopher Fauletb7d30092020-03-30 15:19:03 +02001487
William Dauchyf4300902021-02-06 20:47:50 +01001488 /* 2- start them as far as possible from each other. For this, we will
1489 * start them after their interval is set to the min interval divided
1490 * by the number of servers, weighted by the server's position in the
1491 * list.
Christopher Faulet61cc8522020-04-20 14:54:42 +02001492 */
1493 for (px = proxies_list; px; px = px->next) {
1494 if ((px->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
1495 if (init_pid_list()) {
1496 ha_alert("Starting [%s] check: out of memory.\n", px->id);
1497 return ERR_ALERT | ERR_FATAL;
1498 }
1499 }
Christopher Fauletb7d30092020-03-30 15:19:03 +02001500
Christopher Faulet61cc8522020-04-20 14:54:42 +02001501 for (s = px->srv; s; s = s->next) {
1502 /* A task for the main check */
1503 if (s->check.state & CHK_ST_CONFIGURED) {
1504 if (s->check.type == PR_O2_EXT_CHK) {
1505 if (!prepare_external_check(&s->check))
1506 return ERR_ALERT | ERR_FATAL;
Christopher Fauletb7d30092020-03-30 15:19:03 +02001507 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001508 if (!start_check_task(&s->check, mininter, nbcheck, srvpos))
1509 return ERR_ALERT | ERR_FATAL;
1510 srvpos++;
Christopher Faulet98572322020-03-30 13:16:44 +02001511 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001512
Christopher Faulet61cc8522020-04-20 14:54:42 +02001513 /* A task for a auxiliary agent check */
1514 if (s->agent.state & CHK_ST_CONFIGURED) {
1515 if (!start_check_task(&s->agent, mininter, nbcheck, srvpos)) {
1516 return ERR_ALERT | ERR_FATAL;
1517 }
1518 srvpos++;
1519 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001520 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001521 }
Christopher Fauletfc633b62020-11-06 15:24:23 +01001522 return ERR_NONE;
Christopher Faulet61cc8522020-04-20 14:54:42 +02001523}
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001524
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001525
Christopher Faulet61cc8522020-04-20 14:54:42 +02001526/*
1527 * Return value:
1528 * the port to be used for the health check
1529 * 0 in case no port could be found for the check
1530 */
1531static int srv_check_healthcheck_port(struct check *chk)
1532{
1533 int i = 0;
1534 struct server *srv = NULL;
1535
1536 srv = chk->server;
1537
William Dauchyf4300902021-02-06 20:47:50 +01001538 /* by default, we use the health check port configured */
Christopher Faulet61cc8522020-04-20 14:54:42 +02001539 if (chk->port > 0)
1540 return chk->port;
1541
1542 /* try to get the port from check_core.addr if check.port not set */
1543 i = get_host_port(&chk->addr);
1544 if (i > 0)
1545 return i;
1546
1547 /* try to get the port from server address */
1548 /* prevent MAPPORTS from working at this point, since checks could
1549 * not be performed in such case (MAPPORTS impose a relative ports
1550 * based on live traffic)
1551 */
1552 if (srv->flags & SRV_F_MAPPORTS)
1553 return 0;
1554
1555 i = srv->svc_port; /* by default */
1556 if (i > 0)
1557 return i;
1558
1559 return 0;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001560}
1561
Christopher Faulet61cc8522020-04-20 14:54:42 +02001562/* Initializes an health-check attached to the server <srv>. Non-zero is returned
1563 * if an error occurred.
1564 */
1565static int init_srv_check(struct server *srv)
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001566{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001567 const char *err;
1568 struct tcpcheck_rule *r;
Christopher Fauletfc633b62020-11-06 15:24:23 +01001569 int ret = ERR_NONE;
Amaury Denoyelle0519bd42020-11-13 12:34:56 +01001570 int check_type;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001571
Christopher Faulet6ecd5932021-01-12 17:29:45 +01001572 if (!srv->do_check || !(srv->proxy->cap & PR_CAP_BE))
Christopher Faulet61cc8522020-04-20 14:54:42 +02001573 goto out;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001574
Amaury Denoyelle0519bd42020-11-13 12:34:56 +01001575 check_type = srv->check.tcpcheck_rules->flags & TCPCHK_RULES_PROTO_CHK;
Christopher Fauletf50f4e92020-03-30 19:52:29 +02001576
Christopher Faulet61cc8522020-04-20 14:54:42 +02001577 /* If neither a port nor an addr was specified and no check transport
1578 * layer is forced, then the transport layer used by the checks is the
1579 * same as for the production traffic. Otherwise we use raw_sock by
1580 * default, unless one is specified.
1581 */
1582 if (!srv->check.port && !is_addr(&srv->check.addr)) {
1583 if (!srv->check.use_ssl && srv->use_ssl != -1) {
1584 srv->check.use_ssl = srv->use_ssl;
1585 srv->check.xprt = srv->xprt;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001586 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001587 else if (srv->check.use_ssl == 1)
1588 srv->check.xprt = xprt_get(XPRT_SSL);
1589 srv->check.send_proxy |= (srv->pp_opts);
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001590 }
Christopher Faulet66163ec2020-05-20 22:36:24 +02001591 else if (srv->check.use_ssl == 1)
1592 srv->check.xprt = xprt_get(XPRT_SSL);
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001593
Christopher Faulet12882cf2020-04-23 15:50:18 +02001594 /* Inherit the mux protocol from the server if not already defined for
1595 * the check
1596 */
Amaury Denoyelle0519bd42020-11-13 12:34:56 +01001597 if (srv->mux_proto && !srv->check.mux_proto &&
1598 ((srv->mux_proto->mode == PROTO_MODE_HTTP && check_type == TCPCHK_RULES_HTTP_CHK) ||
1599 (srv->mux_proto->mode == PROTO_MODE_TCP && check_type != TCPCHK_RULES_HTTP_CHK))) {
Christopher Faulet12882cf2020-04-23 15:50:18 +02001600 srv->check.mux_proto = srv->mux_proto;
Amaury Denoyelle0519bd42020-11-13 12:34:56 +01001601 }
Amaury Denoyelle7c148902020-11-13 12:34:57 +01001602 /* test that check proto is valid if explicitly defined */
1603 else if (srv->check.mux_proto &&
1604 ((srv->check.mux_proto->mode == PROTO_MODE_HTTP && check_type != TCPCHK_RULES_HTTP_CHK) ||
1605 (srv->check.mux_proto->mode == PROTO_MODE_TCP && check_type == TCPCHK_RULES_HTTP_CHK))) {
1606 ha_alert("config: %s '%s': server '%s' uses an incompatible MUX protocol for the selected check type\n",
1607 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1608 ret |= ERR_ALERT | ERR_FATAL;
1609 goto out;
1610 }
Christopher Faulet12882cf2020-04-23 15:50:18 +02001611
Christopher Faulet61cc8522020-04-20 14:54:42 +02001612 /* validate <srv> server health-check settings */
Christopher Fauletf50f4e92020-03-30 19:52:29 +02001613
Christopher Faulet61cc8522020-04-20 14:54:42 +02001614 /* We need at least a service port, a check port or the first tcp-check
1615 * rule must be a 'connect' one when checking an IPv4/IPv6 server.
1616 */
1617 if ((srv_check_healthcheck_port(&srv->check) != 0) ||
1618 (!is_inet_addr(&srv->check.addr) && (is_addr(&srv->check.addr) || !is_inet_addr(&srv->addr))))
1619 goto init;
Christopher Fauletf50f4e92020-03-30 19:52:29 +02001620
Christopher Faulet61cc8522020-04-20 14:54:42 +02001621 if (!srv->proxy->tcpcheck_rules.list || LIST_ISEMPTY(srv->proxy->tcpcheck_rules.list)) {
1622 ha_alert("config: %s '%s': server '%s' has neither service port nor check port.\n",
1623 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1624 ret |= ERR_ALERT | ERR_ABORT;
1625 goto out;
1626 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001627
Christopher Faulet61cc8522020-04-20 14:54:42 +02001628 /* search the first action (connect / send / expect) in the list */
1629 r = get_first_tcpcheck_rule(&srv->proxy->tcpcheck_rules);
1630 if (!r || (r->action != TCPCHK_ACT_CONNECT) || (!r->connect.port && !get_host_port(&r->connect.addr))) {
1631 ha_alert("config: %s '%s': server '%s' has neither service port nor check port "
1632 "nor tcp_check rule 'connect' with port information.\n",
1633 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1634 ret |= ERR_ALERT | ERR_ABORT;
1635 goto out;
1636 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001637
Christopher Faulet61cc8522020-04-20 14:54:42 +02001638 /* scan the tcp-check ruleset to ensure a port has been configured */
1639 list_for_each_entry(r, srv->proxy->tcpcheck_rules.list, list) {
Willy Tarreau565f3332021-07-22 11:06:41 +02001640 if ((r->action == TCPCHK_ACT_CONNECT) && (!r->connect.port && !get_host_port(&r->connect.addr))) {
Christopher Faulet61cc8522020-04-20 14:54:42 +02001641 ha_alert("config: %s '%s': server '%s' has neither service port nor check port, "
1642 "and a tcp_check rule 'connect' with no port information.\n",
1643 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1644 ret |= ERR_ALERT | ERR_ABORT;
1645 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001646 }
Christopher Faulete5870d82020-04-15 11:32:03 +02001647 }
1648
Christopher Faulet61cc8522020-04-20 14:54:42 +02001649 init:
1650 if (!(srv->proxy->options2 & PR_O2_CHK_ANY)) {
1651 struct tcpcheck_ruleset *rs = NULL;
1652 struct tcpcheck_rules *rules = &srv->proxy->tcpcheck_rules;
1653 //char *errmsg = NULL;
Christopher Faulete5870d82020-04-15 11:32:03 +02001654
Christopher Faulet61cc8522020-04-20 14:54:42 +02001655 srv->proxy->options2 &= ~PR_O2_CHK_ANY;
1656 srv->proxy->options2 |= PR_O2_TCPCHK_CHK;
Christopher Faulete5870d82020-04-15 11:32:03 +02001657
Christopher Faulet61cc8522020-04-20 14:54:42 +02001658 rs = find_tcpcheck_ruleset("*tcp-check");
1659 if (!rs) {
1660 rs = create_tcpcheck_ruleset("*tcp-check");
1661 if (rs == NULL) {
1662 ha_alert("config: %s '%s': out of memory.\n",
1663 proxy_type_str(srv->proxy), srv->proxy->id);
1664 ret |= ERR_ALERT | ERR_FATAL;
1665 goto out;
1666 }
Christopher Faulete5870d82020-04-15 11:32:03 +02001667 }
1668
Christopher Faulet61cc8522020-04-20 14:54:42 +02001669 free_tcpcheck_vars(&rules->preset_vars);
1670 rules->list = &rs->rules;
1671 rules->flags = 0;
Christopher Faulete5870d82020-04-15 11:32:03 +02001672 }
1673
Christopher Faulet61cc8522020-04-20 14:54:42 +02001674 err = init_check(&srv->check, srv->proxy->options2 & PR_O2_CHK_ANY);
1675 if (err) {
1676 ha_alert("config: %s '%s': unable to init check for server '%s' (%s).\n",
1677 proxy_type_str(srv->proxy), srv->proxy->id, srv->id, err);
1678 ret |= ERR_ALERT | ERR_ABORT;
1679 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001680 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001681 srv->check.state |= CHK_ST_CONFIGURED | CHK_ST_ENABLED;
1682 global.maxsock++;
Christopher Faulete5870d82020-04-15 11:32:03 +02001683
Christopher Faulet61cc8522020-04-20 14:54:42 +02001684 out:
1685 return ret;
Christopher Faulete5870d82020-04-15 11:32:03 +02001686}
1687
Christopher Faulet61cc8522020-04-20 14:54:42 +02001688/* Initializes an agent-check attached to the server <srv>. Non-zero is returned
1689 * if an error occurred.
1690 */
1691static int init_srv_agent_check(struct server *srv)
Christopher Faulete5870d82020-04-15 11:32:03 +02001692{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001693 struct tcpcheck_rule *chk;
1694 const char *err;
Christopher Fauletfc633b62020-11-06 15:24:23 +01001695 int ret = ERR_NONE;
Christopher Faulete5870d82020-04-15 11:32:03 +02001696
Christopher Faulet6ecd5932021-01-12 17:29:45 +01001697 if (!srv->do_agent || !(srv->proxy->cap & PR_CAP_BE))
Christopher Faulet61cc8522020-04-20 14:54:42 +02001698 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001699
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001700 /* If there is no connect rule preceding all send / expect rules, an
Christopher Faulet61cc8522020-04-20 14:54:42 +02001701 * implicit one is inserted before all others.
1702 */
1703 chk = get_first_tcpcheck_rule(srv->agent.tcpcheck_rules);
1704 if (!chk || chk->action != TCPCHK_ACT_CONNECT) {
1705 chk = calloc(1, sizeof(*chk));
1706 if (!chk) {
1707 ha_alert("config : %s '%s': unable to add implicit tcp-check connect rule"
1708 " to agent-check for server '%s' (out of memory).\n",
1709 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1710 ret |= ERR_ALERT | ERR_FATAL;
1711 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001712 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001713 chk->action = TCPCHK_ACT_CONNECT;
1714 chk->connect.options = (TCPCHK_OPT_DEFAULT_CONNECT|TCPCHK_OPT_IMPLICIT);
Willy Tarreau2b718102021-04-21 07:32:39 +02001715 LIST_INSERT(srv->agent.tcpcheck_rules->list, &chk->list);
Christopher Faulete5870d82020-04-15 11:32:03 +02001716 }
1717
Christopher Faulet8af4ab82022-08-24 11:38:03 +02001718 /* <chk> is always defined here and it is a CONNECT action. If there is
1719 * a preset variable, it means there is an agent string defined and data
1720 * will be sent after the connect.
1721 */
1722 if (!LIST_ISEMPTY(&srv->agent.tcpcheck_rules->preset_vars))
1723 chk->connect.options |= TCPCHK_OPT_HAS_DATA;
1724
Christopher Faulete5870d82020-04-15 11:32:03 +02001725
Christopher Faulet61cc8522020-04-20 14:54:42 +02001726 err = init_check(&srv->agent, PR_O2_TCPCHK_CHK);
1727 if (err) {
1728 ha_alert("config: %s '%s': unable to init agent-check for server '%s' (%s).\n",
1729 proxy_type_str(srv->proxy), srv->proxy->id, srv->id, err);
1730 ret |= ERR_ALERT | ERR_ABORT;
1731 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001732 }
1733
Christopher Faulet61cc8522020-04-20 14:54:42 +02001734 if (!srv->agent.inter)
1735 srv->agent.inter = srv->check.inter;
1736
1737 srv->agent.state |= CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT;
1738 global.maxsock++;
1739
1740 out:
1741 return ret;
Christopher Faulete5870d82020-04-15 11:32:03 +02001742}
1743
Christopher Faulet61cc8522020-04-20 14:54:42 +02001744static void deinit_srv_check(struct server *srv)
1745{
1746 if (srv->check.state & CHK_ST_CONFIGURED)
1747 free_check(&srv->check);
1748 srv->check.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED;
1749 srv->do_check = 0;
1750}
Christopher Faulete5870d82020-04-15 11:32:03 +02001751
Christopher Faulet61cc8522020-04-20 14:54:42 +02001752
1753static void deinit_srv_agent_check(struct server *srv)
1754{
1755 if (srv->agent.tcpcheck_rules) {
1756 free_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001757 ha_free(&srv->agent.tcpcheck_rules);
Christopher Faulete5870d82020-04-15 11:32:03 +02001758 }
Christopher Faulete5870d82020-04-15 11:32:03 +02001759
Christopher Faulet61cc8522020-04-20 14:54:42 +02001760 if (srv->agent.state & CHK_ST_CONFIGURED)
1761 free_check(&srv->agent);
1762
1763 srv->agent.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED & ~CHK_ST_AGENT;
1764 srv->do_agent = 0;
Christopher Faulete5870d82020-04-15 11:32:03 +02001765}
1766
Willy Tarreaucee013e2020-06-05 11:40:38 +02001767REGISTER_POST_SERVER_CHECK(init_srv_check);
1768REGISTER_POST_SERVER_CHECK(init_srv_agent_check);
Willy Tarreaucee013e2020-06-05 11:40:38 +02001769REGISTER_POST_CHECK(start_checks);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001770
Willy Tarreaucee013e2020-06-05 11:40:38 +02001771REGISTER_SERVER_DEINIT(deinit_srv_check);
1772REGISTER_SERVER_DEINIT(deinit_srv_agent_check);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001773
Christopher Faulet61cc8522020-04-20 14:54:42 +02001774
1775/**************************************************************************/
1776/************************** Check sample fetches **************************/
1777/**************************************************************************/
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001778
Christopher Faulet61cc8522020-04-20 14:54:42 +02001779static struct sample_fetch_kw_list smp_kws = {ILH, {
Christopher Faulet61cc8522020-04-20 14:54:42 +02001780 { /* END */ },
1781}};
1782
1783INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
1784
1785
1786/**************************************************************************/
1787/************************ Check's parsing functions ***********************/
1788/**************************************************************************/
Christopher Fauletce8111e2020-04-06 15:04:11 +02001789/* Parse the "addr" server keyword */
1790static int srv_parse_addr(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
1791 char **errmsg)
1792{
1793 struct sockaddr_storage *sk;
Christopher Fauletce8111e2020-04-06 15:04:11 +02001794 int port1, port2, err_code = 0;
1795
1796
1797 if (!*args[*cur_arg+1]) {
1798 memprintf(errmsg, "'%s' expects <ipv4|ipv6> as argument.", args[*cur_arg]);
1799 goto error;
1800 }
1801
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001802 sk = str2sa_range(args[*cur_arg+1], NULL, &port1, &port2, NULL, NULL, errmsg, NULL, NULL,
1803 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Christopher Fauletce8111e2020-04-06 15:04:11 +02001804 if (!sk) {
1805 memprintf(errmsg, "'%s' : %s", args[*cur_arg], *errmsg);
1806 goto error;
1807 }
1808
William Dauchy1c921cd2021-02-03 22:30:08 +01001809 srv->check.addr = *sk;
1810 /* if agentaddr was never set, we can use addr */
1811 if (!(srv->flags & SRV_F_AGENTADDR))
1812 srv->agent.addr = *sk;
Christopher Fauletce8111e2020-04-06 15:04:11 +02001813
1814 out:
1815 return err_code;
1816
1817 error:
1818 err_code |= ERR_ALERT | ERR_FATAL;
1819 goto out;
1820}
1821
Christopher Fauletcbba66c2020-04-06 14:26:30 +02001822/* Parse the "agent-addr" server keyword */
1823static int srv_parse_agent_addr(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
1824 char **errmsg)
1825{
William Dauchy1c921cd2021-02-03 22:30:08 +01001826 struct sockaddr_storage sk;
Christopher Fauletcbba66c2020-04-06 14:26:30 +02001827 int err_code = 0;
1828
1829 if (!*(args[*cur_arg+1])) {
1830 memprintf(errmsg, "'%s' expects an address as argument.", args[*cur_arg]);
1831 goto error;
1832 }
William Dauchy1c921cd2021-02-03 22:30:08 +01001833 memset(&sk, 0, sizeof(sk));
1834 if (str2ip(args[*cur_arg + 1], &sk) == NULL) {
Christopher Fauletcbba66c2020-04-06 14:26:30 +02001835 memprintf(errmsg, "parsing agent-addr failed. Check if '%s' is correct address.", args[*cur_arg+1]);
1836 goto error;
1837 }
William Dauchy1c921cd2021-02-03 22:30:08 +01001838 set_srv_agent_addr(srv, &sk);
Christopher Fauletcbba66c2020-04-06 14:26:30 +02001839
1840 out:
1841 return err_code;
1842
1843 error:
1844 err_code |= ERR_ALERT | ERR_FATAL;
1845 goto out;
1846}
1847
1848/* Parse the "agent-check" server keyword */
1849static int srv_parse_agent_check(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
1850 char **errmsg)
1851{
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001852 struct tcpcheck_ruleset *rs = NULL;
1853 struct tcpcheck_rules *rules = srv->agent.tcpcheck_rules;
1854 struct tcpcheck_rule *chk;
1855 int err_code = 0;
1856
1857 if (srv->do_agent)
1858 goto out;
1859
Christopher Faulet6ecd5932021-01-12 17:29:45 +01001860 if (!(curpx->cap & PR_CAP_BE)) {
1861 memprintf(errmsg, "'%s' ignored because %s '%s' has no backend capability",
1862 args[*cur_arg], proxy_type_str(curpx), curpx->id);
1863 return ERR_WARN;
1864 }
1865
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001866 if (!rules) {
1867 rules = calloc(1, sizeof(*rules));
1868 if (!rules) {
1869 memprintf(errmsg, "out of memory.");
1870 goto error;
1871 }
1872 LIST_INIT(&rules->preset_vars);
1873 srv->agent.tcpcheck_rules = rules;
1874 }
1875 rules->list = NULL;
1876 rules->flags = 0;
1877
Christopher Faulet61cc8522020-04-20 14:54:42 +02001878 rs = find_tcpcheck_ruleset("*agent-check");
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001879 if (rs)
1880 goto ruleset_found;
1881
Christopher Faulet61cc8522020-04-20 14:54:42 +02001882 rs = create_tcpcheck_ruleset("*agent-check");
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001883 if (rs == NULL) {
1884 memprintf(errmsg, "out of memory.");
1885 goto error;
1886 }
1887
Christopher Fauletb50b3e62020-05-05 18:43:43 +02001888 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send-lf", "%[var(check.agent_string)]", ""},
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001889 1, curpx, &rs->rules, srv->conf.file, srv->conf.line, errmsg);
1890 if (!chk) {
1891 memprintf(errmsg, "'%s': %s", args[*cur_arg], *errmsg);
1892 goto error;
1893 }
1894 chk->index = 0;
Willy Tarreau2b718102021-04-21 07:32:39 +02001895 LIST_APPEND(&rs->rules, &chk->list);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001896
1897 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "custom", ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02001898 1, curpx, &rs->rules, TCPCHK_RULES_AGENT_CHK,
1899 srv->conf.file, srv->conf.line, errmsg);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001900 if (!chk) {
1901 memprintf(errmsg, "'%s': %s", args[*cur_arg], *errmsg);
1902 goto error;
1903 }
1904 chk->expect.custom = tcpcheck_agent_expect_reply;
1905 chk->index = 1;
Willy Tarreau2b718102021-04-21 07:32:39 +02001906 LIST_APPEND(&rs->rules, &chk->list);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001907
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001908 ruleset_found:
1909 rules->list = &rs->rules;
Christopher Faulet1faf18a2020-11-25 16:43:12 +01001910 rules->flags &= ~(TCPCHK_RULES_PROTO_CHK|TCPCHK_RULES_UNUSED_RS);
Christopher Faulet404f9192020-04-09 23:13:54 +02001911 rules->flags |= TCPCHK_RULES_AGENT_CHK;
Christopher Fauletcbba66c2020-04-06 14:26:30 +02001912 srv->do_agent = 1;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001913
1914 out:
Dirkjan Bussink1065e7e2021-06-18 19:57:49 +00001915 return err_code;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001916
1917 error:
1918 deinit_srv_agent_check(srv);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001919 free_tcpcheck_ruleset(rs);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001920 err_code |= ERR_ALERT | ERR_FATAL;
1921 goto out;
Christopher Fauletcbba66c2020-04-06 14:26:30 +02001922}
1923
1924/* Parse the "agent-inter" server keyword */
1925static int srv_parse_agent_inter(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
1926 char **errmsg)
1927{
1928 const char *err = NULL;
1929 unsigned int delay;
1930 int err_code = 0;
1931
1932 if (!*(args[*cur_arg+1])) {
1933 memprintf(errmsg, "'%s' expects a delay as argument.", args[*cur_arg]);
1934 goto error;
1935 }
1936
1937 err = parse_time_err(args[*cur_arg+1], &delay, TIME_UNIT_MS);
1938 if (err == PARSE_TIME_OVER) {
1939 memprintf(errmsg, "timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
1940 args[*cur_arg+1], args[*cur_arg], srv->id);
1941 goto error;
1942 }
1943 else if (err == PARSE_TIME_UNDER) {
1944 memprintf(errmsg, "timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
1945 args[*cur_arg+1], args[*cur_arg], srv->id);
1946 goto error;
1947 }
1948 else if (err) {
1949 memprintf(errmsg, "unexpected character '%c' in 'agent-inter' argument of server %s.",
1950 *err, srv->id);
1951 goto error;
1952 }
1953 if (delay <= 0) {
1954 memprintf(errmsg, "invalid value %d for argument '%s' of server %s.",
1955 delay, args[*cur_arg], srv->id);
1956 goto error;
1957 }
1958 srv->agent.inter = delay;
1959
1960 out:
1961 return err_code;
1962
1963 error:
1964 err_code |= ERR_ALERT | ERR_FATAL;
1965 goto out;
1966}
1967
1968/* Parse the "agent-port" server keyword */
1969static int srv_parse_agent_port(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
1970 char **errmsg)
1971{
1972 int err_code = 0;
1973
1974 if (!*(args[*cur_arg+1])) {
1975 memprintf(errmsg, "'%s' expects a port number as argument.", args[*cur_arg]);
1976 goto error;
1977 }
1978
1979 global.maxsock++;
William Dauchy4858fb22021-02-03 22:30:09 +01001980 set_srv_agent_port(srv, atol(args[*cur_arg + 1]));
Christopher Fauletcbba66c2020-04-06 14:26:30 +02001981
1982 out:
1983 return err_code;
1984
1985 error:
1986 err_code |= ERR_ALERT | ERR_FATAL;
1987 goto out;
1988}
1989
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001990int set_srv_agent_send(struct server *srv, const char *send)
1991{
1992 struct tcpcheck_rules *rules = srv->agent.tcpcheck_rules;
1993 struct tcpcheck_var *var = NULL;
1994 char *str;
1995
1996 str = strdup(send);
Christopher Fauletb61caf42020-04-21 10:57:42 +02001997 var = create_tcpcheck_var(ist("check.agent_string"));
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001998 if (str == NULL || var == NULL)
1999 goto error;
2000
2001 free_tcpcheck_vars(&rules->preset_vars);
2002
2003 var->data.type = SMP_T_STR;
2004 var->data.u.str.area = str;
2005 var->data.u.str.data = strlen(str);
2006 LIST_INIT(&var->list);
Willy Tarreau2b718102021-04-21 07:32:39 +02002007 LIST_APPEND(&rules->preset_vars, &var->list);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002008
2009 return 1;
2010
2011 error:
2012 free(str);
2013 free(var);
2014 return 0;
2015}
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002016
William Dauchyf4300902021-02-06 20:47:50 +01002017/* set agent addr and appropriate flag */
William Dauchy1c921cd2021-02-03 22:30:08 +01002018inline void set_srv_agent_addr(struct server *srv, struct sockaddr_storage *sk)
2019{
2020 srv->agent.addr = *sk;
2021 srv->flags |= SRV_F_AGENTADDR;
2022}
2023
William Dauchyf4300902021-02-06 20:47:50 +01002024/* set agent port and appropriate flag */
William Dauchy4858fb22021-02-03 22:30:09 +01002025inline void set_srv_agent_port(struct server *srv, int port)
2026{
2027 srv->agent.port = port;
2028 srv->flags |= SRV_F_AGENTPORT;
2029}
2030
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002031/* Parse the "agent-send" server keyword */
2032static int srv_parse_agent_send(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2033 char **errmsg)
2034{
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002035 struct tcpcheck_rules *rules = srv->agent.tcpcheck_rules;
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002036 int err_code = 0;
2037
2038 if (!*(args[*cur_arg+1])) {
2039 memprintf(errmsg, "'%s' expects a string as argument.", args[*cur_arg]);
2040 goto error;
2041 }
2042
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002043 if (!rules) {
2044 rules = calloc(1, sizeof(*rules));
2045 if (!rules) {
2046 memprintf(errmsg, "out of memory.");
2047 goto error;
2048 }
2049 LIST_INIT(&rules->preset_vars);
2050 srv->agent.tcpcheck_rules = rules;
2051 }
2052
2053 if (!set_srv_agent_send(srv, args[*cur_arg+1])) {
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002054 memprintf(errmsg, "out of memory.");
2055 goto error;
2056 }
2057
2058 out:
2059 return err_code;
2060
2061 error:
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002062 deinit_srv_agent_check(srv);
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002063 err_code |= ERR_ALERT | ERR_FATAL;
2064 goto out;
2065}
2066
2067/* Parse the "no-agent-send" server keyword */
2068static int srv_parse_no_agent_check(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2069 char **errmsg)
2070{
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002071 deinit_srv_agent_check(srv);
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002072 return 0;
2073}
2074
Christopher Fauletce8111e2020-04-06 15:04:11 +02002075/* Parse the "check" server keyword */
2076static int srv_parse_check(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2077 char **errmsg)
2078{
Christopher Faulet6ecd5932021-01-12 17:29:45 +01002079 if (!(curpx->cap & PR_CAP_BE)) {
2080 memprintf(errmsg, "'%s' ignored because %s '%s' has no backend capability",
2081 args[*cur_arg], proxy_type_str(curpx), curpx->id);
2082 return ERR_WARN;
2083 }
2084
Christopher Fauletce8111e2020-04-06 15:04:11 +02002085 srv->do_check = 1;
2086 return 0;
2087}
2088
2089/* Parse the "check-send-proxy" server keyword */
2090static int srv_parse_check_send_proxy(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2091 char **errmsg)
2092{
2093 srv->check.send_proxy = 1;
2094 return 0;
2095}
2096
2097/* Parse the "check-via-socks4" server keyword */
2098static int srv_parse_check_via_socks4(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2099 char **errmsg)
2100{
2101 srv->check.via_socks4 = 1;
2102 return 0;
2103}
2104
2105/* Parse the "no-check" server keyword */
2106static int srv_parse_no_check(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2107 char **errmsg)
2108{
2109 deinit_srv_check(srv);
2110 return 0;
2111}
2112
2113/* Parse the "no-check-send-proxy" server keyword */
2114static int srv_parse_no_check_send_proxy(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2115 char **errmsg)
2116{
2117 srv->check.send_proxy = 0;
2118 return 0;
2119}
2120
Christopher Fauletedc6ed92020-04-23 16:27:59 +02002121/* parse the "check-proto" server keyword */
2122static int srv_parse_check_proto(char **args, int *cur_arg,
2123 struct proxy *px, struct server *newsrv, char **err)
2124{
2125 int err_code = 0;
2126
2127 if (!*args[*cur_arg + 1]) {
2128 memprintf(err, "'%s' : missing value", args[*cur_arg]);
2129 goto error;
2130 }
Tim Duesterhusdcf753a2021-03-04 17:31:47 +01002131 newsrv->check.mux_proto = get_mux_proto(ist(args[*cur_arg + 1]));
Christopher Fauletedc6ed92020-04-23 16:27:59 +02002132 if (!newsrv->check.mux_proto) {
2133 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
2134 goto error;
2135 }
2136
2137 out:
2138 return err_code;
2139
2140 error:
2141 err_code |= ERR_ALERT | ERR_FATAL;
2142 goto out;
2143}
2144
2145
Christopher Fauletce8111e2020-04-06 15:04:11 +02002146/* Parse the "rise" server keyword */
2147static int srv_parse_check_rise(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2148 char **errmsg)
2149{
2150 int err_code = 0;
2151
2152 if (!*args[*cur_arg + 1]) {
2153 memprintf(errmsg, "'%s' expects an integer argument.", args[*cur_arg]);
2154 goto error;
2155 }
2156
2157 srv->check.rise = atol(args[*cur_arg+1]);
2158 if (srv->check.rise <= 0) {
2159 memprintf(errmsg, "'%s' has to be > 0.", args[*cur_arg]);
2160 goto error;
2161 }
2162
2163 if (srv->check.health)
2164 srv->check.health = srv->check.rise;
2165
2166 out:
2167 return err_code;
2168
2169 error:
2170 deinit_srv_agent_check(srv);
2171 err_code |= ERR_ALERT | ERR_FATAL;
2172 goto out;
Christopher Fauletce8111e2020-04-06 15:04:11 +02002173}
2174
2175/* Parse the "fall" server keyword */
2176static int srv_parse_check_fall(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2177 char **errmsg)
2178{
2179 int err_code = 0;
2180
2181 if (!*args[*cur_arg + 1]) {
2182 memprintf(errmsg, "'%s' expects an integer argument.", args[*cur_arg]);
2183 goto error;
2184 }
2185
2186 srv->check.fall = atol(args[*cur_arg+1]);
2187 if (srv->check.fall <= 0) {
2188 memprintf(errmsg, "'%s' has to be > 0.", args[*cur_arg]);
2189 goto error;
2190 }
2191
2192 out:
2193 return err_code;
2194
2195 error:
2196 deinit_srv_agent_check(srv);
2197 err_code |= ERR_ALERT | ERR_FATAL;
2198 goto out;
Christopher Fauletce8111e2020-04-06 15:04:11 +02002199}
2200
2201/* Parse the "inter" server keyword */
2202static int srv_parse_check_inter(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2203 char **errmsg)
2204{
2205 const char *err = NULL;
2206 unsigned int delay;
2207 int err_code = 0;
2208
2209 if (!*(args[*cur_arg+1])) {
2210 memprintf(errmsg, "'%s' expects a delay as argument.", args[*cur_arg]);
2211 goto error;
2212 }
2213
2214 err = parse_time_err(args[*cur_arg+1], &delay, TIME_UNIT_MS);
2215 if (err == PARSE_TIME_OVER) {
2216 memprintf(errmsg, "timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
2217 args[*cur_arg+1], args[*cur_arg], srv->id);
2218 goto error;
2219 }
2220 else if (err == PARSE_TIME_UNDER) {
2221 memprintf(errmsg, "timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
2222 args[*cur_arg+1], args[*cur_arg], srv->id);
2223 goto error;
2224 }
2225 else if (err) {
2226 memprintf(errmsg, "unexpected character '%c' in 'agent-inter' argument of server %s.",
2227 *err, srv->id);
2228 goto error;
2229 }
2230 if (delay <= 0) {
2231 memprintf(errmsg, "invalid value %d for argument '%s' of server %s.",
2232 delay, args[*cur_arg], srv->id);
2233 goto error;
2234 }
2235 srv->check.inter = delay;
2236
2237 out:
2238 return err_code;
2239
2240 error:
2241 err_code |= ERR_ALERT | ERR_FATAL;
2242 goto out;
2243}
2244
2245
2246/* Parse the "fastinter" server keyword */
2247static int srv_parse_check_fastinter(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2248 char **errmsg)
2249{
2250 const char *err = NULL;
2251 unsigned int delay;
2252 int err_code = 0;
2253
2254 if (!*(args[*cur_arg+1])) {
2255 memprintf(errmsg, "'%s' expects a delay as argument.", args[*cur_arg]);
2256 goto error;
2257 }
2258
2259 err = parse_time_err(args[*cur_arg+1], &delay, TIME_UNIT_MS);
2260 if (err == PARSE_TIME_OVER) {
2261 memprintf(errmsg, "timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
2262 args[*cur_arg+1], args[*cur_arg], srv->id);
2263 goto error;
2264 }
2265 else if (err == PARSE_TIME_UNDER) {
2266 memprintf(errmsg, "timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
2267 args[*cur_arg+1], args[*cur_arg], srv->id);
2268 goto error;
2269 }
2270 else if (err) {
2271 memprintf(errmsg, "unexpected character '%c' in 'agent-inter' argument of server %s.",
2272 *err, srv->id);
2273 goto error;
2274 }
2275 if (delay <= 0) {
2276 memprintf(errmsg, "invalid value %d for argument '%s' of server %s.",
2277 delay, args[*cur_arg], srv->id);
2278 goto error;
2279 }
2280 srv->check.fastinter = delay;
2281
2282 out:
2283 return err_code;
2284
2285 error:
2286 err_code |= ERR_ALERT | ERR_FATAL;
2287 goto out;
2288}
2289
2290
2291/* Parse the "downinter" server keyword */
2292static int srv_parse_check_downinter(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2293 char **errmsg)
2294{
2295 const char *err = NULL;
2296 unsigned int delay;
2297 int err_code = 0;
2298
2299 if (!*(args[*cur_arg+1])) {
2300 memprintf(errmsg, "'%s' expects a delay as argument.", args[*cur_arg]);
2301 goto error;
2302 }
2303
2304 err = parse_time_err(args[*cur_arg+1], &delay, TIME_UNIT_MS);
2305 if (err == PARSE_TIME_OVER) {
2306 memprintf(errmsg, "timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
2307 args[*cur_arg+1], args[*cur_arg], srv->id);
2308 goto error;
2309 }
2310 else if (err == PARSE_TIME_UNDER) {
2311 memprintf(errmsg, "timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
2312 args[*cur_arg+1], args[*cur_arg], srv->id);
2313 goto error;
2314 }
2315 else if (err) {
2316 memprintf(errmsg, "unexpected character '%c' in 'agent-inter' argument of server %s.",
2317 *err, srv->id);
2318 goto error;
2319 }
2320 if (delay <= 0) {
2321 memprintf(errmsg, "invalid value %d for argument '%s' of server %s.",
2322 delay, args[*cur_arg], srv->id);
2323 goto error;
2324 }
2325 srv->check.downinter = delay;
2326
2327 out:
2328 return err_code;
2329
2330 error:
2331 err_code |= ERR_ALERT | ERR_FATAL;
2332 goto out;
2333}
2334
2335/* Parse the "port" server keyword */
2336static int srv_parse_check_port(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2337 char **errmsg)
2338{
2339 int err_code = 0;
2340
2341 if (!*(args[*cur_arg+1])) {
2342 memprintf(errmsg, "'%s' expects a port number as argument.", args[*cur_arg]);
2343 goto error;
2344 }
2345
2346 global.maxsock++;
2347 srv->check.port = atol(args[*cur_arg+1]);
William Dauchy4858fb22021-02-03 22:30:09 +01002348 /* if agentport was never set, we can use port */
2349 if (!(srv->flags & SRV_F_AGENTPORT))
2350 srv->agent.port = srv->check.port;
Christopher Fauletce8111e2020-04-06 15:04:11 +02002351
2352 out:
2353 return err_code;
2354
2355 error:
2356 err_code |= ERR_ALERT | ERR_FATAL;
2357 goto out;
2358}
2359
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002360static struct srv_kw_list srv_kws = { "CHK", { }, {
Amaury Denoyelle76e10e72021-03-08 17:08:01 +01002361 { "addr", srv_parse_addr, 1, 1, 0 }, /* IP address to send health to or to probe from agent-check */
2362 { "agent-addr", srv_parse_agent_addr, 1, 1, 0 }, /* Enable an auxiliary agent check */
2363 { "agent-check", srv_parse_agent_check, 0, 1, 0 }, /* Enable agent checks */
2364 { "agent-inter", srv_parse_agent_inter, 1, 1, 0 }, /* Set the interval between two agent checks */
2365 { "agent-port", srv_parse_agent_port, 1, 1, 0 }, /* Set the TCP port used for agent checks. */
2366 { "agent-send", srv_parse_agent_send, 1, 1, 0 }, /* Set string to send to agent. */
2367 { "check", srv_parse_check, 0, 1, 0 }, /* Enable health checks */
2368 { "check-proto", srv_parse_check_proto, 1, 1, 0 }, /* Set the mux protocol for health checks */
2369 { "check-send-proxy", srv_parse_check_send_proxy, 0, 1, 0 }, /* Enable PROXY protocol for health checks */
2370 { "check-via-socks4", srv_parse_check_via_socks4, 0, 1, 0 }, /* Enable socks4 proxy for health checks */
2371 { "no-agent-check", srv_parse_no_agent_check, 0, 1, 0 }, /* Do not enable any auxiliary agent check */
2372 { "no-check", srv_parse_no_check, 0, 1, 0 }, /* Disable health checks */
2373 { "no-check-send-proxy", srv_parse_no_check_send_proxy, 0, 1, 0 }, /* Disable PROXY protocol for health checks */
2374 { "rise", srv_parse_check_rise, 1, 1, 0 }, /* Set rise value for health checks */
2375 { "fall", srv_parse_check_fall, 1, 1, 0 }, /* Set fall value for health checks */
2376 { "inter", srv_parse_check_inter, 1, 1, 0 }, /* Set inter value for health checks */
2377 { "fastinter", srv_parse_check_fastinter, 1, 1, 0 }, /* Set fastinter value for health checks */
2378 { "downinter", srv_parse_check_downinter, 1, 1, 0 }, /* Set downinter value for health checks */
2379 { "port", srv_parse_check_port, 1, 1, 0 }, /* Set the TCP port used for health checks. */
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002380 { NULL, NULL, 0 },
2381}};
2382
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002383INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Christopher Fauletfd6c2292020-03-25 18:20:15 +01002384
Willy Tarreaubd741542010-03-16 18:46:54 +01002385/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02002386 * Local variables:
2387 * c-indent-level: 8
2388 * c-basic-offset: 8
2389 * End:
2390 */