blob: c9802a603965ee45e20cf7d024937301995f8c83 [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>
Willy Tarreaueb92deb2020-06-04 10:53:16 +020039#include <haproxy/dns.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>
57#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020058#include <haproxy/server.h>
Willy Tarreau209108d2020-06-04 20:30:20 +020059#include <haproxy/ssl_sock.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020060#include <haproxy/stats-t.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020061#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020062#include <haproxy/task.h>
Willy Tarreau51cd5952020-06-05 12:25:38 +020063#include <haproxy/tcpcheck.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020064#include <haproxy/thread.h>
65#include <haproxy/time.h>
66#include <haproxy/tools.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020067#include <haproxy/vars.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020068
Olivier Houchard9130a962017-10-17 17:33:43 +020069
Christopher Faulet61cc8522020-04-20 14:54:42 +020070static int wake_srv_chk(struct conn_stream *cs);
71struct data_cb check_conn_cb = {
72 .wake = wake_srv_chk,
73 .name = "CHCK",
74};
Christopher Fauletd7e63962020-04-17 20:15:59 +020075
Christopher Faulet5d503fc2020-03-30 20:34:34 +020076
Gaetan Rivet05d692d2020-02-14 17:42:54 +010077/* Dummy frontend used to create all checks sessions. */
Willy Tarreau51cd5952020-06-05 12:25:38 +020078struct proxy checks_fe;
Christopher Faulet31dff9b2017-10-23 15:45:20 +020079
Christopher Faulet61cc8522020-04-20 14:54:42 +020080/**************************************************************************/
81/************************ Handle check results ****************************/
82/**************************************************************************/
83struct check_status {
84 short result; /* one of SRV_CHK_* */
85 char *info; /* human readable short info */
86 char *desc; /* long description */
87};
88
89struct analyze_status {
90 char *desc; /* description */
91 unsigned char lr[HANA_OBS_SIZE]; /* result for l4/l7: 0 = ignore, 1 - error, 2 - OK */
92};
93
Simon Horman63a4a822012-03-19 07:24:41 +090094static const struct check_status check_statuses[HCHK_STATUS_SIZE] = {
Willy Tarreau6aaa1b82013-12-11 17:09:34 +010095 [HCHK_STATUS_UNKNOWN] = { CHK_RES_UNKNOWN, "UNK", "Unknown" },
96 [HCHK_STATUS_INI] = { CHK_RES_UNKNOWN, "INI", "Initializing" },
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +020097 [HCHK_STATUS_START] = { /* SPECIAL STATUS*/ },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +020098
Willy Tarreau23964182014-05-20 20:56:30 +020099 /* Below we have finished checks */
100 [HCHK_STATUS_CHECKED] = { CHK_RES_NEUTRAL, "CHECKED", "No status change" },
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100101 [HCHK_STATUS_HANA] = { CHK_RES_FAILED, "HANA", "Health analyze" },
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100102
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100103 [HCHK_STATUS_SOCKERR] = { CHK_RES_FAILED, "SOCKERR", "Socket error" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200104
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100105 [HCHK_STATUS_L4OK] = { CHK_RES_PASSED, "L4OK", "Layer4 check passed" },
106 [HCHK_STATUS_L4TOUT] = { CHK_RES_FAILED, "L4TOUT", "Layer4 timeout" },
107 [HCHK_STATUS_L4CON] = { CHK_RES_FAILED, "L4CON", "Layer4 connection problem" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200108
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100109 [HCHK_STATUS_L6OK] = { CHK_RES_PASSED, "L6OK", "Layer6 check passed" },
110 [HCHK_STATUS_L6TOUT] = { CHK_RES_FAILED, "L6TOUT", "Layer6 timeout" },
111 [HCHK_STATUS_L6RSP] = { CHK_RES_FAILED, "L6RSP", "Layer6 invalid response" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200112
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100113 [HCHK_STATUS_L7TOUT] = { CHK_RES_FAILED, "L7TOUT", "Layer7 timeout" },
114 [HCHK_STATUS_L7RSP] = { CHK_RES_FAILED, "L7RSP", "Layer7 invalid response" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200115
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200116 [HCHK_STATUS_L57DATA] = { /* DUMMY STATUS */ },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200117
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100118 [HCHK_STATUS_L7OKD] = { CHK_RES_PASSED, "L7OK", "Layer7 check passed" },
119 [HCHK_STATUS_L7OKCD] = { CHK_RES_CONDPASS, "L7OKC", "Layer7 check conditionally passed" },
120 [HCHK_STATUS_L7STS] = { CHK_RES_FAILED, "L7STS", "Layer7 wrong status" },
Simon Horman98637e52014-06-20 12:30:16 +0900121
122 [HCHK_STATUS_PROCERR] = { CHK_RES_FAILED, "PROCERR", "External check error" },
123 [HCHK_STATUS_PROCTOUT] = { CHK_RES_FAILED, "PROCTOUT", "External check timeout" },
Cyril Bonté77010d82014-08-07 01:55:37 +0200124 [HCHK_STATUS_PROCOK] = { CHK_RES_PASSED, "PROCOK", "External check passed" },
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200125};
126
Simon Horman63a4a822012-03-19 07:24:41 +0900127static const struct analyze_status analyze_statuses[HANA_STATUS_SIZE] = { /* 0: ignore, 1: error, 2: OK */
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100128 [HANA_STATUS_UNKNOWN] = { "Unknown", { 0, 0 }},
129
130 [HANA_STATUS_L4_OK] = { "L4 successful connection", { 2, 0 }},
131 [HANA_STATUS_L4_ERR] = { "L4 unsuccessful connection", { 1, 1 }},
132
133 [HANA_STATUS_HTTP_OK] = { "Correct http response", { 0, 2 }},
134 [HANA_STATUS_HTTP_STS] = { "Wrong http response", { 0, 1 }},
135 [HANA_STATUS_HTTP_HDRRSP] = { "Invalid http response (headers)", { 0, 1 }},
136 [HANA_STATUS_HTTP_RSP] = { "Invalid http response", { 0, 1 }},
137
138 [HANA_STATUS_HTTP_READ_ERROR] = { "Read error (http)", { 0, 1 }},
139 [HANA_STATUS_HTTP_READ_TIMEOUT] = { "Read timeout (http)", { 0, 1 }},
140 [HANA_STATUS_HTTP_BROKEN_PIPE] = { "Close from server (http)", { 0, 1 }},
141};
142
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100143/* checks if <err> is a real error for errno or one that can be ignored, and
144 * return 0 for these ones or <err> for real ones.
145 */
146static inline int unclean_errno(int err)
147{
148 if (err == EAGAIN || err == EINPROGRESS ||
149 err == EISCONN || err == EALREADY)
150 return 0;
151 return err;
152}
153
Christopher Faulet61cc8522020-04-20 14:54:42 +0200154/* Converts check_status code to description */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200155const char *get_check_status_description(short check_status) {
156
157 const char *desc;
158
159 if (check_status < HCHK_STATUS_SIZE)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200160 desc = check_statuses[check_status].desc;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200161 else
162 desc = NULL;
163
164 if (desc && *desc)
165 return desc;
166 else
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200167 return check_statuses[HCHK_STATUS_UNKNOWN].desc;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200168}
169
Christopher Faulet61cc8522020-04-20 14:54:42 +0200170/* Converts check_status code to short info */
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200171const char *get_check_status_info(short check_status) {
172
173 const char *info;
174
175 if (check_status < HCHK_STATUS_SIZE)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200176 info = check_statuses[check_status].info;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200177 else
178 info = NULL;
179
180 if (info && *info)
181 return info;
182 else
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200183 return check_statuses[HCHK_STATUS_UNKNOWN].info;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200184}
185
Christopher Faulet61cc8522020-04-20 14:54:42 +0200186/* Convert analyze_status to description */
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100187const char *get_analyze_status(short analyze_status) {
188
189 const char *desc;
190
191 if (analyze_status < HANA_STATUS_SIZE)
192 desc = analyze_statuses[analyze_status].desc;
193 else
194 desc = NULL;
195
196 if (desc && *desc)
197 return desc;
198 else
199 return analyze_statuses[HANA_STATUS_UNKNOWN].desc;
200}
201
Christopher Faulet61cc8522020-04-20 14:54:42 +0200202/* Sets check->status, update check->duration and fill check->result with an
203 * adequate CHK_RES_* value. The new check->health is computed based on the
204 * result.
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200205 *
Christopher Faulet61cc8522020-04-20 14:54:42 +0200206 * Shows information in logs about failed health check if server is UP or
207 * succeeded health checks if server is DOWN.
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200208 */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200209void set_server_check_status(struct check *check, short status, const char *desc)
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100210{
Simon Horman4a741432013-02-23 15:35:38 +0900211 struct server *s = check->server;
Willy Tarreaubef1b322014-05-13 21:01:39 +0200212 short prev_status = check->status;
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200213 int report = 0;
Simon Horman4a741432013-02-23 15:35:38 +0900214
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200215 if (status == HCHK_STATUS_START) {
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100216 check->result = CHK_RES_UNKNOWN; /* no result yet */
Simon Horman4a741432013-02-23 15:35:38 +0900217 check->desc[0] = '\0';
218 check->start = now;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200219 return;
220 }
221
Simon Horman4a741432013-02-23 15:35:38 +0900222 if (!check->status)
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200223 return;
224
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200225 if (desc && *desc) {
Simon Horman4a741432013-02-23 15:35:38 +0900226 strncpy(check->desc, desc, HCHK_DESC_LEN-1);
227 check->desc[HCHK_DESC_LEN-1] = '\0';
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200228 } else
Simon Horman4a741432013-02-23 15:35:38 +0900229 check->desc[0] = '\0';
Krzysztof Piotr Oledzkif7089f52009-10-10 21:06:49 +0200230
Simon Horman4a741432013-02-23 15:35:38 +0900231 check->status = status;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200232 if (check_statuses[status].result)
Simon Horman4a741432013-02-23 15:35:38 +0900233 check->result = check_statuses[status].result;
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200234
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100235 if (status == HCHK_STATUS_HANA)
Simon Horman4a741432013-02-23 15:35:38 +0900236 check->duration = -1;
237 else if (!tv_iszero(&check->start)) {
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200238 /* set_server_check_status() may be called more than once */
Simon Horman4a741432013-02-23 15:35:38 +0900239 check->duration = tv_ms_elapsed(&check->start, &now);
240 tv_zero(&check->start);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200241 }
242
Willy Tarreau23964182014-05-20 20:56:30 +0200243 /* no change is expected if no state change occurred */
244 if (check->result == CHK_RES_NEUTRAL)
245 return;
246
Olivier Houchard0923fa42019-01-11 18:43:04 +0100247 /* If the check was really just sending a mail, it won't have an
248 * associated server, so we're done now.
249 */
250 if (!s)
251 return;
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200252 report = 0;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200253
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200254 switch (check->result) {
255 case CHK_RES_FAILED:
Willy Tarreau12634e12014-05-23 11:32:36 +0200256 /* Failure to connect to the agent as a secondary check should not
257 * cause the server to be marked down.
258 */
259 if ((!(check->state & CHK_ST_AGENT) ||
Simon Hormaneaabd522015-02-26 11:26:17 +0900260 (check->status >= HCHK_STATUS_L57DATA)) &&
Christopher Fauletb119a792018-05-02 12:12:45 +0200261 (check->health > 0)) {
Olivier Houchard7059c552019-03-08 18:49:32 +0100262 _HA_ATOMIC_ADD(&s->counters.failed_checks, 1);
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200263 report = 1;
264 check->health--;
265 if (check->health < check->rise)
266 check->health = 0;
267 }
268 break;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200269
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200270 case CHK_RES_PASSED:
271 case CHK_RES_CONDPASS: /* "condpass" cannot make the first step but it OK after a "passed" */
272 if ((check->health < check->rise + check->fall - 1) &&
273 (check->result == CHK_RES_PASSED || check->health > 0)) {
274 report = 1;
275 check->health++;
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200276
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200277 if (check->health >= check->rise)
278 check->health = check->rise + check->fall - 1; /* OK now */
279 }
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200280
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200281 /* clear consecutive_errors if observing is enabled */
282 if (s->onerror)
283 s->consecutive_errors = 0;
284 break;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100285
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200286 default:
287 break;
288 }
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200289
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200290 if (s->proxy->options2 & PR_O2_LOGHCHKS &&
291 (status != prev_status || report)) {
292 chunk_printf(&trash,
Willy Tarreau12634e12014-05-23 11:32:36 +0200293 "%s check for %sserver %s/%s %s%s",
294 (check->state & CHK_ST_AGENT) ? "Agent" : "Health",
Willy Tarreauc93cd162014-05-13 15:54:22 +0200295 s->flags & SRV_F_BACKUP ? "backup " : "",
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100296 s->proxy->id, s->id,
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100297 (check->result == CHK_RES_CONDPASS) ? "conditionally ":"",
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200298 (check->result >= CHK_RES_PASSED) ? "succeeded" : "failed");
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200299
Emeric Brun5a133512017-10-19 14:42:30 +0200300 srv_append_status(&trash, s, check, -1, 0);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200301
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100302 chunk_appendf(&trash, ", status: %d/%d %s",
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200303 (check->health >= check->rise) ? check->health - check->rise + 1 : check->health,
304 (check->health >= check->rise) ? check->fall : check->rise,
305 (check->health >= check->rise) ? (s->uweight ? "UP" : "DRAIN") : "DOWN");
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200306
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200307 ha_warning("%s.\n", trash.area);
308 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
309 send_email_alert(s, LOG_INFO, "%s", trash.area);
Krzysztof Piotr Oledzki213014e2009-09-27 15:50:02 +0200310 }
Krzysztof Piotr Oledzki09605412009-09-23 22:09:24 +0200311}
312
Willy Tarreau4eec5472014-05-20 22:32:27 +0200313/* Marks the check <check>'s server down if the current check is already failed
314 * and the server is not down yet nor in maintenance.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200315 */
Willy Tarreaubcc67332020-06-05 15:31:31 +0200316void check_notify_failure(struct check *check)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200317{
Simon Horman4a741432013-02-23 15:35:38 +0900318 struct server *s = check->server;
Simon Hormane0d1bfb2011-06-21 14:34:58 +0900319
Willy Tarreau7b1d47c2014-05-20 14:55:13 +0200320 /* The agent secondary check should only cause a server to be marked
321 * as down if check->status is HCHK_STATUS_L7STS, which indicates
322 * that the agent returned "fail", "stopped" or "down".
323 * The implication here is that failure to connect to the agent
324 * as a secondary check should not cause the server to be marked
325 * down. */
326 if ((check->state & CHK_ST_AGENT) && check->status != HCHK_STATUS_L7STS)
327 return;
328
Willy Tarreau4eec5472014-05-20 22:32:27 +0200329 if (check->health > 0)
330 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100331
Willy Tarreau4eec5472014-05-20 22:32:27 +0200332 /* We only report a reason for the check if we did not do so previously */
Emeric Brun5a133512017-10-19 14:42:30 +0200333 srv_set_stopped(s, NULL, (!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS)) ? check : NULL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200334}
335
Willy Tarreauaf549582014-05-16 17:37:50 +0200336/* Marks the check <check> as valid and tries to set its server up, provided
Willy Tarreau3e048382014-05-21 10:30:54 +0200337 * it isn't in maintenance, it is not tracking a down server and other checks
338 * comply. The rule is simple : by default, a server is up, unless any of the
339 * following conditions is true :
340 * - health check failed (check->health < rise)
341 * - agent check failed (agent->health < rise)
342 * - the server tracks a down server (track && track->state == STOPPED)
343 * Note that if the server has a slowstart, it will switch to STARTING instead
344 * of RUNNING. Also, only the health checks support the nolb mode, so the
345 * agent's success may not take the server out of this mode.
Willy Tarreauaf549582014-05-16 17:37:50 +0200346 */
Willy Tarreaubcc67332020-06-05 15:31:31 +0200347void check_notify_success(struct check *check)
Willy Tarreauaf549582014-05-16 17:37:50 +0200348{
Simon Horman4a741432013-02-23 15:35:38 +0900349 struct server *s = check->server;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100350
Emeric Brun52a91d32017-08-31 14:41:55 +0200351 if (s->next_admin & SRV_ADMF_MAINT)
Willy Tarreauaf549582014-05-16 17:37:50 +0200352 return;
Cyril Bontécd19e512010-01-31 22:34:03 +0100353
Emeric Brun52a91d32017-08-31 14:41:55 +0200354 if (s->track && s->track->next_state == SRV_ST_STOPPED)
Willy Tarreauaf549582014-05-16 17:37:50 +0200355 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100356
Willy Tarreau3e048382014-05-21 10:30:54 +0200357 if ((s->check.state & CHK_ST_ENABLED) && (s->check.health < s->check.rise))
358 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100359
Willy Tarreau3e048382014-05-21 10:30:54 +0200360 if ((s->agent.state & CHK_ST_ENABLED) && (s->agent.health < s->agent.rise))
361 return;
Willy Tarreauaf549582014-05-16 17:37:50 +0200362
Emeric Brun52a91d32017-08-31 14:41:55 +0200363 if ((check->state & CHK_ST_AGENT) && s->next_state == SRV_ST_STOPPING)
Willy Tarreau3e048382014-05-21 10:30:54 +0200364 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100365
Emeric Brun5a133512017-10-19 14:42:30 +0200366 srv_set_running(s, NULL, (!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS)) ? check : NULL);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100367}
368
Willy Tarreaudb58b792014-05-21 13:57:23 +0200369/* Marks the check <check> as valid and tries to set its server into stopping mode
370 * if it was running or starting, and provided it isn't in maintenance and other
371 * checks comply. The conditions for the server to be marked in stopping mode are
372 * the same as for it to be turned up. Also, only the health checks support the
373 * nolb mode.
Willy Tarreauaf549582014-05-16 17:37:50 +0200374 */
Willy Tarreaubcc67332020-06-05 15:31:31 +0200375void check_notify_stopping(struct check *check)
Willy Tarreauaf549582014-05-16 17:37:50 +0200376{
Simon Horman4a741432013-02-23 15:35:38 +0900377 struct server *s = check->server;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100378
Emeric Brun52a91d32017-08-31 14:41:55 +0200379 if (s->next_admin & SRV_ADMF_MAINT)
Willy Tarreauaf549582014-05-16 17:37:50 +0200380 return;
381
Willy Tarreaudb58b792014-05-21 13:57:23 +0200382 if (check->state & CHK_ST_AGENT)
383 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100384
Emeric Brun52a91d32017-08-31 14:41:55 +0200385 if (s->track && s->track->next_state == SRV_ST_STOPPED)
Willy Tarreaudb58b792014-05-21 13:57:23 +0200386 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100387
Willy Tarreaudb58b792014-05-21 13:57:23 +0200388 if ((s->check.state & CHK_ST_ENABLED) && (s->check.health < s->check.rise))
389 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100390
Willy Tarreaudb58b792014-05-21 13:57:23 +0200391 if ((s->agent.state & CHK_ST_ENABLED) && (s->agent.health < s->agent.rise))
392 return;
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100393
Willy Tarreaub26881a2017-12-23 11:16:49 +0100394 srv_set_stopping(s, NULL, (!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS)) ? check : NULL);
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100395}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200396
Willy Tarreau9fe7aae2013-12-31 23:47:37 +0100397/* note: use health_adjust() only, which first checks that the observe mode is
398 * enabled.
399 */
400void __health_adjust(struct server *s, short status)
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100401{
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100402 int failed;
403 int expire;
404
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100405 if (s->observe >= HANA_OBS_SIZE)
406 return;
407
Willy Tarreaubb956662013-01-24 00:37:39 +0100408 if (status >= HANA_STATUS_SIZE || !analyze_statuses[status].desc)
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100409 return;
410
411 switch (analyze_statuses[status].lr[s->observe - 1]) {
412 case 1:
413 failed = 1;
414 break;
415
416 case 2:
417 failed = 0;
418 break;
419
420 default:
421 return;
422 }
423
424 if (!failed) {
425 /* good: clear consecutive_errors */
426 s->consecutive_errors = 0;
427 return;
428 }
429
Olivier Houchard7059c552019-03-08 18:49:32 +0100430 _HA_ATOMIC_ADD(&s->consecutive_errors, 1);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100431
432 if (s->consecutive_errors < s->consecutive_errors_limit)
433 return;
434
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100435 chunk_printf(&trash, "Detected %d consecutive errors, last one was: %s",
436 s->consecutive_errors, get_analyze_status(status));
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100437
438 switch (s->onerror) {
439 case HANA_ONERR_FASTINTER:
440 /* force fastinter - nothing to do here as all modes force it */
441 break;
442
443 case HANA_ONERR_SUDDTH:
444 /* simulate a pre-fatal failed health check */
Simon Horman58c32972013-11-25 10:46:38 +0900445 if (s->check.health > s->check.rise)
446 s->check.health = s->check.rise + 1;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100447
Tim Duesterhus588b3142020-05-29 14:35:51 +0200448 /* fall through */
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100449
450 case HANA_ONERR_FAILCHK:
451 /* simulate a failed health check */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200452 set_server_check_status(&s->check, HCHK_STATUS_HANA,
453 trash.area);
Willy Tarreau4eec5472014-05-20 22:32:27 +0200454 check_notify_failure(&s->check);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100455 break;
456
457 case HANA_ONERR_MARKDWN:
458 /* mark server down */
Simon Horman58c32972013-11-25 10:46:38 +0900459 s->check.health = s->check.rise;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200460 set_server_check_status(&s->check, HCHK_STATUS_HANA,
461 trash.area);
Willy Tarreau4eec5472014-05-20 22:32:27 +0200462 check_notify_failure(&s->check);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100463 break;
464
465 default:
466 /* write a warning? */
467 break;
468 }
469
470 s->consecutive_errors = 0;
Olivier Houchard7059c552019-03-08 18:49:32 +0100471 _HA_ATOMIC_ADD(&s->counters.failed_hana, 1);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100472
Simon Horman66183002013-02-23 10:16:43 +0900473 if (s->check.fastinter) {
474 expire = tick_add(now_ms, MS_TO_TICKS(s->check.fastinter));
Sergiy Prykhodko1d57e502013-09-21 12:05:00 +0300475 if (s->check.task->expire > expire) {
Willy Tarreau5b3a2022012-09-28 15:01:02 +0200476 s->check.task->expire = expire;
Sergiy Prykhodko1d57e502013-09-21 12:05:00 +0300477 /* requeue check task with new expire */
478 task_queue(s->check.task);
479 }
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100480 }
Willy Tarreauef781042010-01-27 11:53:01 +0100481}
482
Christopher Faulet61cc8522020-04-20 14:54:42 +0200483/* Checks the connection. If an error has already been reported or the socket is
Willy Tarreau20a18342013-12-05 00:31:46 +0100484 * closed, keep errno intact as it is supposed to contain the valid error code.
485 * If no error is reported, check the socket's error queue using getsockopt().
486 * Warning, this must be done only once when returning from poll, and never
487 * after an I/O error was attempted, otherwise the error queue might contain
488 * inconsistent errors. If an error is detected, the CO_FL_ERROR is set on the
489 * socket. Returns non-zero if an error was reported, zero if everything is
490 * clean (including a properly closed socket).
491 */
492static int retrieve_errno_from_socket(struct connection *conn)
493{
494 int skerr;
495 socklen_t lskerr = sizeof(skerr);
496
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100497 if (conn->flags & CO_FL_ERROR && (unclean_errno(errno) || !conn->ctrl))
Willy Tarreau20a18342013-12-05 00:31:46 +0100498 return 1;
499
Willy Tarreau3c728722014-01-23 13:50:42 +0100500 if (!conn_ctrl_ready(conn))
Willy Tarreau20a18342013-12-05 00:31:46 +0100501 return 0;
502
Willy Tarreau585744b2017-08-24 14:31:19 +0200503 if (getsockopt(conn->handle.fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr) == 0)
Willy Tarreau20a18342013-12-05 00:31:46 +0100504 errno = skerr;
505
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100506 errno = unclean_errno(errno);
Willy Tarreau20a18342013-12-05 00:31:46 +0100507
508 if (!errno) {
509 /* we could not retrieve an error, that does not mean there is
510 * none. Just don't change anything and only report the prior
511 * error if any.
512 */
513 if (conn->flags & CO_FL_ERROR)
514 return 1;
515 else
516 return 0;
517 }
518
519 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_WR_SH | CO_FL_SOCK_RD_SH;
520 return 1;
521}
522
Christopher Faulet61cc8522020-04-20 14:54:42 +0200523/* Tries to collect as much information as possible on the connection status,
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100524 * and adjust the server status accordingly. It may make use of <errno_bck>
525 * if non-null when the caller is absolutely certain of its validity (eg:
526 * checked just after a syscall). If the caller doesn't have a valid errno,
527 * it can pass zero, and retrieve_errno_from_socket() will be called to try
528 * to extract errno from the socket. If no error is reported, it will consider
529 * the <expired> flag. This is intended to be used when a connection error was
530 * reported in conn->flags or when a timeout was reported in <expired>. The
531 * function takes care of not updating a server status which was already set.
532 * All situations where at least one of <expired> or CO_FL_ERROR are set
533 * produce a status.
534 */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200535void chk_report_conn_err(struct check *check, int errno_bck, int expired)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100536{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200537 struct conn_stream *cs = check->cs;
538 struct connection *conn = cs_conn(cs);
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100539 const char *err_msg;
Willy Tarreau83061a82018-07-13 11:56:34 +0200540 struct buffer *chk;
Willy Tarreau213c6782014-10-02 14:51:02 +0200541 int step;
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100542
Willy Tarreau6aaa1b82013-12-11 17:09:34 +0100543 if (check->result != CHK_RES_UNKNOWN)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100544 return;
545
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100546 errno = unclean_errno(errno_bck);
547 if (conn && errno)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100548 retrieve_errno_from_socket(conn);
549
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200550 if (conn && !(conn->flags & CO_FL_ERROR) &&
551 !(cs->flags & CS_FL_ERROR) && !expired)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100552 return;
553
554 /* we'll try to build a meaningful error message depending on the
555 * context of the error possibly present in conn->err_code, and the
556 * socket error possibly collected above. This is useful to know the
557 * exact step of the L6 layer (eg: SSL handshake).
558 */
Baptiste Assmann5ecb77f2013-10-06 23:24:13 +0200559 chk = get_trash_chunk();
560
Christopher Faulet799f3a42020-04-07 12:06:14 +0200561 if (check->type == PR_O2_TCPCHK_CHK &&
Christopher Fauletd7e63962020-04-17 20:15:59 +0200562 (check->tcpcheck_rules->flags & TCPCHK_RULES_PROTO_CHK) == TCPCHK_RULES_TCP_CHK) {
Christopher Fauletb2c2e0f2020-03-30 11:05:10 +0200563 step = tcpcheck_get_step_id(check, NULL);
Willy Tarreau213c6782014-10-02 14:51:02 +0200564 if (!step)
565 chunk_printf(chk, " at initial connection step of tcp-check");
566 else {
567 chunk_printf(chk, " at step %d of tcp-check", step);
568 /* we were looking for a string */
Christopher Fauletb2c2e0f2020-03-30 11:05:10 +0200569 if (check->current_step && check->current_step->action == TCPCHK_ACT_CONNECT) {
570 if (check->current_step->connect.port)
571 chunk_appendf(chk, " (connect port %d)" ,check->current_step->connect.port);
Willy Tarreau213c6782014-10-02 14:51:02 +0200572 else
573 chunk_appendf(chk, " (connect)");
574 }
Christopher Fauletb2c2e0f2020-03-30 11:05:10 +0200575 else if (check->current_step && check->current_step->action == TCPCHK_ACT_EXPECT) {
576 struct tcpcheck_expect *expect = &check->current_step->expect;
Gaetan Rivetb616add2020-02-07 15:37:17 +0100577
578 switch (expect->type) {
579 case TCPCHK_EXPECT_STRING:
Christopher Fauletb61caf42020-04-21 10:57:42 +0200580 chunk_appendf(chk, " (expect string '%.*s')", (unsigned int)istlen(expect->data), istptr(expect->data));
Gaetan Rivetb616add2020-02-07 15:37:17 +0100581 break;
582 case TCPCHK_EXPECT_BINARY:
Christopher Fauletb61caf42020-04-21 10:57:42 +0200583 chunk_appendf(chk, " (expect binary '%.*s')", (unsigned int)istlen(expect->data), istptr(expect->data));
Gaetan Rivetb616add2020-02-07 15:37:17 +0100584 break;
Christopher Faulet67a23452020-05-05 18:10:01 +0200585 case TCPCHK_EXPECT_STRING_REGEX:
Willy Tarreau213c6782014-10-02 14:51:02 +0200586 chunk_appendf(chk, " (expect regex)");
Gaetan Rivetb616add2020-02-07 15:37:17 +0100587 break;
Christopher Faulet67a23452020-05-05 18:10:01 +0200588 case TCPCHK_EXPECT_BINARY_REGEX:
Gaetan Rivetefab6c62020-02-07 15:37:17 +0100589 chunk_appendf(chk, " (expect binary regex)");
590 break;
Christopher Fauletaaab0832020-05-05 15:54:22 +0200591 case TCPCHK_EXPECT_STRING_LF:
592 chunk_appendf(chk, " (expect log-format string)");
593 break;
594 case TCPCHK_EXPECT_BINARY_LF:
595 chunk_appendf(chk, " (expect log-format binary)");
596 break;
Christopher Faulete5870d82020-04-15 11:32:03 +0200597 case TCPCHK_EXPECT_HTTP_STATUS:
Christopher Faulet8021a5f2020-04-24 13:53:12 +0200598 chunk_appendf(chk, " (expect HTTP status codes)");
Christopher Faulete5870d82020-04-15 11:32:03 +0200599 break;
Christopher Faulet67a23452020-05-05 18:10:01 +0200600 case TCPCHK_EXPECT_HTTP_STATUS_REGEX:
Christopher Faulete5870d82020-04-15 11:32:03 +0200601 chunk_appendf(chk, " (expect HTTP status regex)");
602 break;
Christopher Faulet39708192020-05-05 10:47:36 +0200603 case TCPCHK_EXPECT_HTTP_HEADER:
604 chunk_appendf(chk, " (expect HTTP header pattern)");
605 break;
Christopher Faulete5870d82020-04-15 11:32:03 +0200606 case TCPCHK_EXPECT_HTTP_BODY:
Christopher Fauletb61caf42020-04-21 10:57:42 +0200607 chunk_appendf(chk, " (expect HTTP body content '%.*s')", (unsigned int)istlen(expect->data), istptr(expect->data));
Christopher Faulete5870d82020-04-15 11:32:03 +0200608 break;
Christopher Faulet67a23452020-05-05 18:10:01 +0200609 case TCPCHK_EXPECT_HTTP_BODY_REGEX:
Christopher Faulete5870d82020-04-15 11:32:03 +0200610 chunk_appendf(chk, " (expect HTTP body regex)");
611 break;
Christopher Fauletaaab0832020-05-05 15:54:22 +0200612 case TCPCHK_EXPECT_HTTP_BODY_LF:
613 chunk_appendf(chk, " (expect log-format HTTP body)");
614 break;
Christopher Faulet9e6ed152020-04-03 15:24:06 +0200615 case TCPCHK_EXPECT_CUSTOM:
616 chunk_appendf(chk, " (expect custom function)");
617 break;
Gaetan Rivetb616add2020-02-07 15:37:17 +0100618 case TCPCHK_EXPECT_UNDEF:
619 chunk_appendf(chk, " (undefined expect!)");
620 break;
621 }
Willy Tarreau213c6782014-10-02 14:51:02 +0200622 }
Christopher Fauletb2c2e0f2020-03-30 11:05:10 +0200623 else if (check->current_step && check->current_step->action == TCPCHK_ACT_SEND) {
Willy Tarreau213c6782014-10-02 14:51:02 +0200624 chunk_appendf(chk, " (send)");
625 }
Baptiste Assmann22b09d22015-05-01 08:03:04 +0200626
Christopher Faulet6f2a5e42020-04-01 13:11:41 +0200627 if (check->current_step && check->current_step->comment)
628 chunk_appendf(chk, " comment: '%s'", check->current_step->comment);
Baptiste Assmann5ecb77f2013-10-06 23:24:13 +0200629 }
630 }
631
Willy Tarreau00149122017-10-04 18:05:01 +0200632 if (conn && conn->err_code) {
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100633 if (unclean_errno(errno))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200634 chunk_printf(&trash, "%s (%s)%s", conn_err_code_str(conn), strerror(errno),
635 chk->area);
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100636 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200637 chunk_printf(&trash, "%s%s", conn_err_code_str(conn),
638 chk->area);
639 err_msg = trash.area;
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100640 }
641 else {
Willy Tarreauc8dc20a2019-12-27 12:03:27 +0100642 if (unclean_errno(errno)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200643 chunk_printf(&trash, "%s%s", strerror(errno),
644 chk->area);
645 err_msg = trash.area;
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100646 }
647 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200648 err_msg = chk->area;
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100649 }
650 }
651
Willy Tarreau00149122017-10-04 18:05:01 +0200652 if (check->state & CHK_ST_PORT_MISS) {
Baptiste Assmann95db2bc2016-06-13 14:15:41 +0200653 /* NOTE: this is reported after <fall> tries */
654 chunk_printf(chk, "No port available for the TCP connection");
655 set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
656 }
657
Willy Tarreau00149122017-10-04 18:05:01 +0200658 if (!conn) {
659 /* connection allocation error before the connection was established */
660 set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
661 }
Willy Tarreauc192b0a2020-01-23 09:11:58 +0100662 else if (conn->flags & CO_FL_WAIT_L4_CONN) {
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100663 /* L4 not established (yet) */
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200664 if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100665 set_server_check_status(check, HCHK_STATUS_L4CON, err_msg);
666 else if (expired)
667 set_server_check_status(check, HCHK_STATUS_L4TOUT, err_msg);
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200668
669 /*
670 * might be due to a server IP change.
671 * Let's trigger a DNS resolution if none are currently running.
672 */
Olivier Houchard0923fa42019-01-11 18:43:04 +0100673 if (check->server)
674 dns_trigger_resolution(check->server->dns_requester);
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200675
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100676 }
Willy Tarreauc192b0a2020-01-23 09:11:58 +0100677 else if (conn->flags & CO_FL_WAIT_L6_CONN) {
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100678 /* L6 not established (yet) */
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200679 if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100680 set_server_check_status(check, HCHK_STATUS_L6RSP, err_msg);
681 else if (expired)
682 set_server_check_status(check, HCHK_STATUS_L6TOUT, err_msg);
683 }
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200684 else if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR) {
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100685 /* I/O error after connection was established and before we could diagnose */
686 set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
687 }
688 else if (expired) {
Christopher Fauletcf80f2f2020-04-01 11:04:52 +0200689 enum healthcheck_status tout = HCHK_STATUS_L7TOUT;
690
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100691 /* connection established but expired check */
Christopher Faulet1941bab2020-05-05 07:55:50 +0200692 if (check->current_step && check->current_step->action == TCPCHK_ACT_EXPECT &&
693 check->current_step->expect.tout_status != HCHK_STATUS_UNKNOWN)
Christopher Faulet811f78c2020-04-01 11:10:27 +0200694 tout = check->current_step->expect.tout_status;
695 set_server_check_status(check, tout, err_msg);
Willy Tarreau25e2ab52013-12-04 11:17:05 +0100696 }
697
698 return;
699}
700
Simon Horman98637e52014-06-20 12:30:16 +0900701
Christopher Faulet61cc8522020-04-20 14:54:42 +0200702/* Builds the server state header used by HTTP health-checks */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200703int httpchk_build_status_header(struct server *s, struct buffer *buf)
Simon Horman98637e52014-06-20 12:30:16 +0900704{
Christopher Faulet61cc8522020-04-20 14:54:42 +0200705 int sv_state;
706 int ratio;
707 char addr[46];
708 char port[6];
709 const char *srv_hlt_st[7] = { "DOWN", "DOWN %d/%d",
710 "UP %d/%d", "UP",
711 "NOLB %d/%d", "NOLB",
712 "no check" };
Simon Horman98637e52014-06-20 12:30:16 +0900713
Christopher Faulet61cc8522020-04-20 14:54:42 +0200714 if (!(s->check.state & CHK_ST_ENABLED))
715 sv_state = 6;
716 else if (s->cur_state != SRV_ST_STOPPED) {
717 if (s->check.health == s->check.rise + s->check.fall - 1)
718 sv_state = 3; /* UP */
719 else
720 sv_state = 2; /* going down */
Simon Horman98637e52014-06-20 12:30:16 +0900721
Christopher Faulet61cc8522020-04-20 14:54:42 +0200722 if (s->cur_state == SRV_ST_STOPPING)
723 sv_state += 2;
724 } else {
725 if (s->check.health)
726 sv_state = 1; /* going up */
727 else
728 sv_state = 0; /* DOWN */
Simon Horman98637e52014-06-20 12:30:16 +0900729 }
Willy Tarreaub7b24782016-06-21 15:32:29 +0200730
Christopher Faulet61cc8522020-04-20 14:54:42 +0200731 chunk_appendf(buf, srv_hlt_st[sv_state],
732 (s->cur_state != SRV_ST_STOPPED) ? (s->check.health - s->check.rise + 1) : (s->check.health),
733 (s->cur_state != SRV_ST_STOPPED) ? (s->check.fall) : (s->check.rise));
Willy Tarreaub7b24782016-06-21 15:32:29 +0200734
Christopher Faulet61cc8522020-04-20 14:54:42 +0200735 addr_to_str(&s->addr, addr, sizeof(addr));
736 if (s->addr.ss_family == AF_INET || s->addr.ss_family == AF_INET6)
737 snprintf(port, sizeof(port), "%u", s->svc_port);
738 else
739 *port = 0;
Willy Tarreaub7b24782016-06-21 15:32:29 +0200740
Christopher Faulet61cc8522020-04-20 14:54:42 +0200741 chunk_appendf(buf, "; address=%s; port=%s; name=%s/%s; node=%s; weight=%d/%d; scur=%d/%d; qcur=%d",
742 addr, port, s->proxy->id, s->id,
743 global.node,
744 (s->cur_eweight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv,
745 (s->proxy->lbprm.tot_weight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv,
746 s->cur_sess, s->proxy->beconn - s->proxy->nbpend,
747 s->nbpend);
Willy Tarreau9f6dc722019-03-01 11:15:10 +0100748
Christopher Faulet61cc8522020-04-20 14:54:42 +0200749 if ((s->cur_state == SRV_ST_STARTING) &&
750 now.tv_sec < s->last_change + s->slowstart &&
751 now.tv_sec >= s->last_change) {
752 ratio = MAX(1, 100 * (now.tv_sec - s->last_change) / s->slowstart);
753 chunk_appendf(buf, "; throttle=%d%%", ratio);
754 }
Christopher Fauletaaae9a02020-04-26 09:50:31 +0200755
Christopher Faulet61cc8522020-04-20 14:54:42 +0200756 return b_data(buf);
757}
Christopher Fauletaaae9a02020-04-26 09:50:31 +0200758
Willy Tarreau51cd5952020-06-05 12:25:38 +0200759/**************************************************************************/
Willy Tarreau51cd5952020-06-05 12:25:38 +0200760/***************** Health-checks based on connections *********************/
761/**************************************************************************/
762/* This function is used only for server health-checks. It handles connection
763 * status updates including errors. If necessary, it wakes the check task up.
764 * It returns 0 on normal cases, <0 if at least one close() has happened on the
765 * connection (eg: reconnect). It relies on tcpcheck_main().
Christopher Faulet61cc8522020-04-20 14:54:42 +0200766 */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200767static int wake_srv_chk(struct conn_stream *cs)
Christopher Faulet61cc8522020-04-20 14:54:42 +0200768{
Willy Tarreau51cd5952020-06-05 12:25:38 +0200769 struct connection *conn = cs->conn;
770 struct check *check = cs->data;
771 struct email_alertq *q = container_of(check, typeof(*q), check);
772 int ret = 0;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200773
Willy Tarreau51cd5952020-06-05 12:25:38 +0200774 if (check->server)
775 HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
776 else
777 HA_SPIN_LOCK(EMAIL_ALERTS_LOCK, &q->lock);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200778
Willy Tarreau51cd5952020-06-05 12:25:38 +0200779 /* we may have to make progress on the TCP checks */
780 ret = tcpcheck_main(check);
Christopher Fauletaaab0832020-05-05 15:54:22 +0200781
Willy Tarreau51cd5952020-06-05 12:25:38 +0200782 cs = check->cs;
783 conn = cs->conn;
Christopher Fauletaaab0832020-05-05 15:54:22 +0200784
Willy Tarreau51cd5952020-06-05 12:25:38 +0200785 if (unlikely(conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)) {
786 /* We may get error reports bypassing the I/O handlers, typically
787 * the case when sending a pure TCP check which fails, then the I/O
788 * handlers above are not called. This is completely handled by the
789 * main processing task so let's simply wake it up. If we get here,
790 * we expect errno to still be valid.
791 */
792 chk_report_conn_err(check, errno, 0);
793 task_wakeup(check->task, TASK_WOKEN_IO);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200794 }
795
Willy Tarreau51cd5952020-06-05 12:25:38 +0200796 if (check->result != CHK_RES_UNKNOWN) {
797 /* Check complete or aborted. If connection not yet closed do it
798 * now and wake the check task up to be sure the result is
799 * handled ASAP. */
800 conn_sock_drain(conn);
801 cs_close(cs);
802 ret = -1;
803 /* We may have been scheduled to run, and the
804 * I/O handler expects to have a cs, so remove
805 * the tasklet
806 */
807 tasklet_remove_from_tasklet_list(check->wait_list.tasklet);
808 task_wakeup(check->task, TASK_WOKEN_IO);
Christopher Faulet61cc8522020-04-20 14:54:42 +0200809 }
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200810
Willy Tarreau51cd5952020-06-05 12:25:38 +0200811 if (check->server)
812 HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
813 else
814 HA_SPIN_UNLOCK(EMAIL_ALERTS_LOCK, &q->lock);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200815
Willy Tarreau51cd5952020-06-05 12:25:38 +0200816 /* if a connection got replaced, we must absolutely prevent the connection
817 * handler from touching its fd, and perform the FD polling updates ourselves
818 */
819 if (ret < 0)
820 conn_cond_update_polling(conn);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200821
Christopher Faulet61cc8522020-04-20 14:54:42 +0200822 return ret;
823}
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200824
Willy Tarreau51cd5952020-06-05 12:25:38 +0200825/* This function checks if any I/O is wanted, and if so, attempts to do so */
826static struct task *event_srv_chk_io(struct task *t, void *ctx, unsigned short state)
Christopher Faulet61cc8522020-04-20 14:54:42 +0200827{
Willy Tarreau51cd5952020-06-05 12:25:38 +0200828 struct check *check = ctx;
829 struct conn_stream *cs = check->cs;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200830
Willy Tarreau51cd5952020-06-05 12:25:38 +0200831 wake_srv_chk(cs);
832 return NULL;
Christopher Faulet61cc8522020-04-20 14:54:42 +0200833}
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +0200834
Willy Tarreau51cd5952020-06-05 12:25:38 +0200835/* manages a server health-check that uses a connection. Returns
836 * the time the task accepts to wait, or TIME_ETERNITY for infinity.
Christopher Faulet61cc8522020-04-20 14:54:42 +0200837 *
838 * Please do NOT place any return statement in this function and only leave
Willy Tarreau51cd5952020-06-05 12:25:38 +0200839 * via the out_unlock label.
Christopher Faulet61cc8522020-04-20 14:54:42 +0200840 */
Willy Tarreau51cd5952020-06-05 12:25:38 +0200841static struct task *process_chk_conn(struct task *t, void *context, unsigned short state)
Christopher Faulet61cc8522020-04-20 14:54:42 +0200842{
Willy Tarreau51cd5952020-06-05 12:25:38 +0200843 struct check *check = context;
844 struct proxy *proxy = check->proxy;
Christopher Faulet61cc8522020-04-20 14:54:42 +0200845 struct conn_stream *cs = check->cs;
846 struct connection *conn = cs_conn(cs);
Willy Tarreau51cd5952020-06-05 12:25:38 +0200847 int rv;
848 int expired = tick_is_expired(t->expire, now_ms);
Willy Tarreaudeccd112018-06-14 18:38:55 +0200849
Willy Tarreau51cd5952020-06-05 12:25:38 +0200850 if (check->server)
851 HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
852 if (!(check->state & CHK_ST_INPROGRESS)) {
853 /* no check currently running */
854 if (!expired) /* woke up too early */
855 goto out_unlock;
Willy Tarreauabca5b62013-12-06 14:19:25 +0100856
Willy Tarreau51cd5952020-06-05 12:25:38 +0200857 /* we don't send any health-checks when the proxy is
858 * stopped, the server should not be checked or the check
859 * is disabled.
860 */
861 if (((check->state & (CHK_ST_ENABLED | CHK_ST_PAUSED)) != CHK_ST_ENABLED) ||
862 proxy->state == PR_STSTOPPED)
863 goto reschedule;
Christopher Faulet404f9192020-04-09 23:13:54 +0200864
Willy Tarreau51cd5952020-06-05 12:25:38 +0200865 /* we'll initiate a new check */
866 set_server_check_status(check, HCHK_STATUS_START, NULL);
Christopher Faulet404f9192020-04-09 23:13:54 +0200867
Willy Tarreau51cd5952020-06-05 12:25:38 +0200868 check->state |= CHK_ST_INPROGRESS;
869 b_reset(&check->bi);
870 b_reset(&check->bo);
Christopher Faulet61cc8522020-04-20 14:54:42 +0200871
Willy Tarreau51cd5952020-06-05 12:25:38 +0200872 task_set_affinity(t, tid_bit);
873
874 check->current_step = NULL;
875 tcpcheck_main(check);
876 goto out_unlock;
Christopher Faulet61cc8522020-04-20 14:54:42 +0200877 }
Willy Tarreau51cd5952020-06-05 12:25:38 +0200878 else {
879 /* there was a test running.
880 * First, let's check whether there was an uncaught error,
881 * which can happen on connect timeout or error.
882 */
883 if (check->result == CHK_RES_UNKNOWN) {
884 if ((conn->flags & CO_FL_ERROR) || cs->flags & CS_FL_ERROR || expired) {
885 chk_report_conn_err(check, 0, expired);
886 }
887 else
888 goto out_unlock; /* timeout not reached, wait again */
Christopher Faulet61cc8522020-04-20 14:54:42 +0200889 }
Christopher Faulet404f9192020-04-09 23:13:54 +0200890
Willy Tarreau51cd5952020-06-05 12:25:38 +0200891 /* check complete or aborted */
Christopher Fauletba3c68f2020-04-01 16:27:05 +0200892
Willy Tarreau51cd5952020-06-05 12:25:38 +0200893 check->current_step = NULL;
Christopher Fauletba3c68f2020-04-01 16:27:05 +0200894
Willy Tarreau51cd5952020-06-05 12:25:38 +0200895 if (conn && conn->xprt) {
896 /* The check was aborted and the connection was not yet closed.
897 * This can happen upon timeout, or when an external event such
898 * as a failed response coupled with "observe layer7" caused the
899 * server state to be suddenly changed.
900 */
901 conn_sock_drain(conn);
902 cs_close(cs);
Christopher Faulet61cc8522020-04-20 14:54:42 +0200903 }
Christopher Fauletba3c68f2020-04-01 16:27:05 +0200904
Willy Tarreau51cd5952020-06-05 12:25:38 +0200905 if (cs) {
906 if (check->wait_list.events)
907 cs->conn->mux->unsubscribe(cs, check->wait_list.events, &check->wait_list);
908 /* We may have been scheduled to run, and the
909 * I/O handler expects to have a cs, so remove
910 * the tasklet
911 */
912 tasklet_remove_from_tasklet_list(check->wait_list.tasklet);
913 cs_destroy(cs);
914 cs = check->cs = NULL;
915 conn = NULL;
Christopher Faulet61cc8522020-04-20 14:54:42 +0200916 }
Willy Tarreau51cd5952020-06-05 12:25:38 +0200917
918 if (check->sess != NULL) {
919 vars_prune(&check->vars, check->sess, NULL);
920 session_free(check->sess);
921 check->sess = NULL;
Christopher Faulet61cc8522020-04-20 14:54:42 +0200922 }
Willy Tarreau51cd5952020-06-05 12:25:38 +0200923
924 if (check->server) {
925 if (check->result == CHK_RES_FAILED) {
926 /* a failure or timeout detected */
927 check_notify_failure(check);
928 }
929 else if (check->result == CHK_RES_CONDPASS) {
930 /* check is OK but asks for stopping mode */
931 check_notify_stopping(check);
932 }
933 else if (check->result == CHK_RES_PASSED) {
934 /* a success was detected */
935 check_notify_success(check);
936 }
Christopher Faulet61cc8522020-04-20 14:54:42 +0200937 }
Willy Tarreau51cd5952020-06-05 12:25:38 +0200938 task_set_affinity(t, MAX_THREADS_MASK);
939 check->state &= ~CHK_ST_INPROGRESS;
Christopher Fauletba3c68f2020-04-01 16:27:05 +0200940
Willy Tarreau51cd5952020-06-05 12:25:38 +0200941 if (check->server) {
942 rv = 0;
943 if (global.spread_checks > 0) {
944 rv = srv_getinter(check) * global.spread_checks / 100;
945 rv -= (int) (2 * rv * (ha_random32() / 4294967295.0));
Christopher Faulet61cc8522020-04-20 14:54:42 +0200946 }
Willy Tarreau51cd5952020-06-05 12:25:38 +0200947 t->expire = tick_add(now_ms, MS_TO_TICKS(srv_getinter(check) + rv));
Christopher Faulet61cc8522020-04-20 14:54:42 +0200948 }
Christopher Faulet61cc8522020-04-20 14:54:42 +0200949 }
Willy Tarreau51cd5952020-06-05 12:25:38 +0200950
951 reschedule:
952 while (tick_is_expired(t->expire, now_ms))
953 t->expire = tick_add(t->expire, MS_TO_TICKS(check->inter));
954 out_unlock:
955 if (check->server)
956 HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
957 return t;
Christopher Fauletba3c68f2020-04-01 16:27:05 +0200958}
959
Willy Tarreau51cd5952020-06-05 12:25:38 +0200960
Christopher Faulet61cc8522020-04-20 14:54:42 +0200961/**************************************************************************/
962/************************** Init/deinit checks ****************************/
963/**************************************************************************/
Willy Tarreaucee013e2020-06-05 11:40:38 +0200964const char *init_check(struct check *check, int type)
Christopher Faulet61cc8522020-04-20 14:54:42 +0200965{
966 check->type = type;
Christopher Fauletba3c68f2020-04-01 16:27:05 +0200967
Christopher Faulet61cc8522020-04-20 14:54:42 +0200968 b_reset(&check->bi); check->bi.size = global.tune.chksize;
969 b_reset(&check->bo); check->bo.size = global.tune.chksize;
Christopher Fauletba3c68f2020-04-01 16:27:05 +0200970
Christopher Faulet61cc8522020-04-20 14:54:42 +0200971 check->bi.area = calloc(check->bi.size, sizeof(char));
972 check->bo.area = calloc(check->bo.size, sizeof(char));
Christopher Fauletba3c68f2020-04-01 16:27:05 +0200973
Christopher Faulet61cc8522020-04-20 14:54:42 +0200974 if (!check->bi.area || !check->bo.area)
975 return "out of memory while allocating check buffer";
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100976
Christopher Faulet61cc8522020-04-20 14:54:42 +0200977 check->wait_list.tasklet = tasklet_new();
978 if (!check->wait_list.tasklet)
979 return "out of memory while allocating check tasklet";
980 check->wait_list.events = 0;
981 check->wait_list.tasklet->process = event_srv_chk_io;
982 check->wait_list.tasklet->context = check;
983 return NULL;
984}
985
986void free_check(struct check *check)
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100987{
Christopher Faulet61cc8522020-04-20 14:54:42 +0200988 task_destroy(check->task);
989 if (check->wait_list.tasklet)
990 tasklet_free(check->wait_list.tasklet);
991
992 free(check->bi.area);
993 free(check->bo.area);
994 if (check->cs) {
995 free(check->cs->conn);
996 check->cs->conn = NULL;
997 cs_free(check->cs);
998 check->cs = NULL;
999 }
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001000}
1001
Christopher Faulet61cc8522020-04-20 14:54:42 +02001002/* manages a server health-check. Returns the time the task accepts to wait, or
1003 * TIME_ETERNITY for infinity.
1004 */
Willy Tarreaucee013e2020-06-05 11:40:38 +02001005struct task *process_chk(struct task *t, void *context, unsigned short state)
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001006{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001007 struct check *check = context;
1008
1009 if (check->type == PR_O2_EXT_CHK)
1010 return process_chk_proc(t, context, state);
1011 return process_chk_conn(t, context, state);
1012
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001013}
1014
Christopher Faulet61cc8522020-04-20 14:54:42 +02001015
1016static int start_check_task(struct check *check, int mininter,
1017 int nbcheck, int srvpos)
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001018{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001019 struct task *t;
1020 unsigned long thread_mask = MAX_THREADS_MASK;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001021
Christopher Faulet61cc8522020-04-20 14:54:42 +02001022 if (check->type == PR_O2_EXT_CHK)
1023 thread_mask = 1;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001024
Christopher Faulet61cc8522020-04-20 14:54:42 +02001025 /* task for the check */
1026 if ((t = task_new(thread_mask)) == NULL) {
1027 ha_alert("Starting [%s:%s] check: out of memory.\n",
1028 check->server->proxy->id, check->server->id);
1029 return 0;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001030 }
1031
Christopher Faulet61cc8522020-04-20 14:54:42 +02001032 check->task = t;
1033 t->process = process_chk;
1034 t->context = check;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001035
Christopher Faulet61cc8522020-04-20 14:54:42 +02001036 if (mininter < srv_getinter(check))
1037 mininter = srv_getinter(check);
1038
1039 if (global.max_spread_checks && mininter > global.max_spread_checks)
1040 mininter = global.max_spread_checks;
1041
1042 /* check this every ms */
1043 t->expire = tick_add(now_ms, MS_TO_TICKS(mininter * srvpos / nbcheck));
1044 check->start = now;
1045 task_queue(t);
1046
1047 return 1;
Gaetan Rivet707b52f2020-02-21 18:14:59 +01001048}
1049
Christopher Faulet61cc8522020-04-20 14:54:42 +02001050/* updates the server's weight during a warmup stage. Once the final weight is
1051 * reached, the task automatically stops. Note that any server status change
1052 * must have updated s->last_change accordingly.
1053 */
1054static struct task *server_warmup(struct task *t, void *context, unsigned short state)
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001055{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001056 struct server *s = context;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001057
Christopher Faulet61cc8522020-04-20 14:54:42 +02001058 /* by default, plan on stopping the task */
1059 t->expire = TICK_ETERNITY;
1060 if ((s->next_admin & SRV_ADMF_MAINT) ||
1061 (s->next_state != SRV_ST_STARTING))
1062 return t;
Christopher Faulete5870d82020-04-15 11:32:03 +02001063
Christopher Faulet61cc8522020-04-20 14:54:42 +02001064 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001065
Christopher Faulet61cc8522020-04-20 14:54:42 +02001066 /* recalculate the weights and update the state */
1067 server_recalc_eweight(s, 1);
Christopher Faulet5c288742020-03-31 08:15:58 +02001068
Christopher Faulet61cc8522020-04-20 14:54:42 +02001069 /* probably that we can refill this server with a bit more connections */
1070 pendconn_grab_from_px(s);
Christopher Faulet5c288742020-03-31 08:15:58 +02001071
Christopher Faulet61cc8522020-04-20 14:54:42 +02001072 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Christopher Faulet5c288742020-03-31 08:15:58 +02001073
Christopher Faulet61cc8522020-04-20 14:54:42 +02001074 /* get back there in 1 second or 1/20th of the slowstart interval,
1075 * whichever is greater, resulting in small 5% steps.
1076 */
1077 if (s->next_state == SRV_ST_STARTING)
1078 t->expire = tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20)));
1079 return t;
1080}
1081
1082/*
1083 * Start health-check.
1084 * Returns 0 if OK, ERR_FATAL on error, and prints the error in this case.
1085 */
1086static int start_checks()
1087{
1088
1089 struct proxy *px;
1090 struct server *s;
1091 struct task *t;
1092 int nbcheck=0, mininter=0, srvpos=0;
1093
1094 /* 0- init the dummy frontend used to create all checks sessions */
1095 init_new_proxy(&checks_fe);
1096 checks_fe.cap = PR_CAP_FE | PR_CAP_BE;
1097 checks_fe.mode = PR_MODE_TCP;
1098 checks_fe.maxconn = 0;
1099 checks_fe.conn_retries = CONN_RETRIES;
1100 checks_fe.options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
1101 checks_fe.timeout.client = TICK_ETERNITY;
1102
1103 /* 1- count the checkers to run simultaneously.
1104 * We also determine the minimum interval among all of those which
1105 * have an interval larger than SRV_CHK_INTER_THRES. This interval
1106 * will be used to spread their start-up date. Those which have
1107 * a shorter interval will start independently and will not dictate
1108 * too short an interval for all others.
1109 */
1110 for (px = proxies_list; px; px = px->next) {
1111 for (s = px->srv; s; s = s->next) {
1112 if (s->slowstart) {
1113 if ((t = task_new(MAX_THREADS_MASK)) == NULL) {
1114 ha_alert("Starting [%s:%s] check: out of memory.\n", px->id, s->id);
1115 return ERR_ALERT | ERR_FATAL;
1116 }
1117 /* We need a warmup task that will be called when the server
1118 * state switches from down to up.
1119 */
1120 s->warmup = t;
1121 t->process = server_warmup;
1122 t->context = s;
1123 /* server can be in this state only because of */
1124 if (s->next_state == SRV_ST_STARTING)
1125 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 +02001126 }
1127
Christopher Faulet61cc8522020-04-20 14:54:42 +02001128 if (s->check.state & CHK_ST_CONFIGURED) {
1129 nbcheck++;
1130 if ((srv_getinter(&s->check) >= SRV_CHK_INTER_THRES) &&
1131 (!mininter || mininter > srv_getinter(&s->check)))
1132 mininter = srv_getinter(&s->check);
Christopher Faulet5c288742020-03-31 08:15:58 +02001133 }
1134
Christopher Faulet61cc8522020-04-20 14:54:42 +02001135 if (s->agent.state & CHK_ST_CONFIGURED) {
1136 nbcheck++;
1137 if ((srv_getinter(&s->agent) >= SRV_CHK_INTER_THRES) &&
1138 (!mininter || mininter > srv_getinter(&s->agent)))
1139 mininter = srv_getinter(&s->agent);
1140 }
Christopher Faulet5c288742020-03-31 08:15:58 +02001141 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001142 }
Christopher Fauletb7d30092020-03-30 15:19:03 +02001143
Christopher Faulet61cc8522020-04-20 14:54:42 +02001144 if (!nbcheck)
1145 return 0;
Christopher Fauletb7d30092020-03-30 15:19:03 +02001146
Christopher Faulet61cc8522020-04-20 14:54:42 +02001147 srand((unsigned)time(NULL));
Christopher Fauletb7d30092020-03-30 15:19:03 +02001148
Christopher Faulet61cc8522020-04-20 14:54:42 +02001149 /*
1150 * 2- start them as far as possible from each others. For this, we will
1151 * start them after their interval set to the min interval divided by
1152 * the number of servers, weighted by the server's position in the list.
1153 */
1154 for (px = proxies_list; px; px = px->next) {
1155 if ((px->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
1156 if (init_pid_list()) {
1157 ha_alert("Starting [%s] check: out of memory.\n", px->id);
1158 return ERR_ALERT | ERR_FATAL;
1159 }
1160 }
Christopher Fauletb7d30092020-03-30 15:19:03 +02001161
Christopher Faulet61cc8522020-04-20 14:54:42 +02001162 for (s = px->srv; s; s = s->next) {
1163 /* A task for the main check */
1164 if (s->check.state & CHK_ST_CONFIGURED) {
1165 if (s->check.type == PR_O2_EXT_CHK) {
1166 if (!prepare_external_check(&s->check))
1167 return ERR_ALERT | ERR_FATAL;
Christopher Fauletb7d30092020-03-30 15:19:03 +02001168 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001169 if (!start_check_task(&s->check, mininter, nbcheck, srvpos))
1170 return ERR_ALERT | ERR_FATAL;
1171 srvpos++;
Christopher Faulet98572322020-03-30 13:16:44 +02001172 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001173
Christopher Faulet61cc8522020-04-20 14:54:42 +02001174 /* A task for a auxiliary agent check */
1175 if (s->agent.state & CHK_ST_CONFIGURED) {
1176 if (!start_check_task(&s->agent, mininter, nbcheck, srvpos)) {
1177 return ERR_ALERT | ERR_FATAL;
1178 }
1179 srvpos++;
1180 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001181 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001182 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001183 return 0;
1184}
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001185
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001186
Christopher Faulet61cc8522020-04-20 14:54:42 +02001187/*
1188 * Return value:
1189 * the port to be used for the health check
1190 * 0 in case no port could be found for the check
1191 */
1192static int srv_check_healthcheck_port(struct check *chk)
1193{
1194 int i = 0;
1195 struct server *srv = NULL;
1196
1197 srv = chk->server;
1198
1199 /* by default, we use the health check port ocnfigured */
1200 if (chk->port > 0)
1201 return chk->port;
1202
1203 /* try to get the port from check_core.addr if check.port not set */
1204 i = get_host_port(&chk->addr);
1205 if (i > 0)
1206 return i;
1207
1208 /* try to get the port from server address */
1209 /* prevent MAPPORTS from working at this point, since checks could
1210 * not be performed in such case (MAPPORTS impose a relative ports
1211 * based on live traffic)
1212 */
1213 if (srv->flags & SRV_F_MAPPORTS)
1214 return 0;
1215
1216 i = srv->svc_port; /* by default */
1217 if (i > 0)
1218 return i;
1219
1220 return 0;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001221}
1222
Christopher Faulet61cc8522020-04-20 14:54:42 +02001223/* Initializes an health-check attached to the server <srv>. Non-zero is returned
1224 * if an error occurred.
1225 */
1226static int init_srv_check(struct server *srv)
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001227{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001228 const char *err;
1229 struct tcpcheck_rule *r;
1230 int ret = 0;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001231
Christopher Faulet61cc8522020-04-20 14:54:42 +02001232 if (!srv->do_check)
1233 goto out;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001234
Christopher Fauletf50f4e92020-03-30 19:52:29 +02001235
Christopher Faulet61cc8522020-04-20 14:54:42 +02001236 /* If neither a port nor an addr was specified and no check transport
1237 * layer is forced, then the transport layer used by the checks is the
1238 * same as for the production traffic. Otherwise we use raw_sock by
1239 * default, unless one is specified.
1240 */
1241 if (!srv->check.port && !is_addr(&srv->check.addr)) {
1242 if (!srv->check.use_ssl && srv->use_ssl != -1) {
1243 srv->check.use_ssl = srv->use_ssl;
1244 srv->check.xprt = srv->xprt;
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001245 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001246 else if (srv->check.use_ssl == 1)
1247 srv->check.xprt = xprt_get(XPRT_SSL);
1248 srv->check.send_proxy |= (srv->pp_opts);
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001249 }
Christopher Faulet66163ec2020-05-20 22:36:24 +02001250 else if (srv->check.use_ssl == 1)
1251 srv->check.xprt = xprt_get(XPRT_SSL);
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001252
Christopher Faulet12882cf2020-04-23 15:50:18 +02001253 /* Inherit the mux protocol from the server if not already defined for
1254 * the check
1255 */
1256 if (srv->mux_proto && !srv->check.mux_proto)
1257 srv->check.mux_proto = srv->mux_proto;
1258
Christopher Faulet61cc8522020-04-20 14:54:42 +02001259 /* validate <srv> server health-check settings */
Christopher Fauletf50f4e92020-03-30 19:52:29 +02001260
Christopher Faulet61cc8522020-04-20 14:54:42 +02001261 /* We need at least a service port, a check port or the first tcp-check
1262 * rule must be a 'connect' one when checking an IPv4/IPv6 server.
1263 */
1264 if ((srv_check_healthcheck_port(&srv->check) != 0) ||
1265 (!is_inet_addr(&srv->check.addr) && (is_addr(&srv->check.addr) || !is_inet_addr(&srv->addr))))
1266 goto init;
Christopher Fauletf50f4e92020-03-30 19:52:29 +02001267
Christopher Faulet61cc8522020-04-20 14:54:42 +02001268 if (!srv->proxy->tcpcheck_rules.list || LIST_ISEMPTY(srv->proxy->tcpcheck_rules.list)) {
1269 ha_alert("config: %s '%s': server '%s' has neither service port nor check port.\n",
1270 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1271 ret |= ERR_ALERT | ERR_ABORT;
1272 goto out;
1273 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001274
Christopher Faulet61cc8522020-04-20 14:54:42 +02001275 /* search the first action (connect / send / expect) in the list */
1276 r = get_first_tcpcheck_rule(&srv->proxy->tcpcheck_rules);
1277 if (!r || (r->action != TCPCHK_ACT_CONNECT) || (!r->connect.port && !get_host_port(&r->connect.addr))) {
1278 ha_alert("config: %s '%s': server '%s' has neither service port nor check port "
1279 "nor tcp_check rule 'connect' with port information.\n",
1280 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1281 ret |= ERR_ALERT | ERR_ABORT;
1282 goto out;
1283 }
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001284
Christopher Faulet61cc8522020-04-20 14:54:42 +02001285 /* scan the tcp-check ruleset to ensure a port has been configured */
1286 list_for_each_entry(r, srv->proxy->tcpcheck_rules.list, list) {
1287 if ((r->action == TCPCHK_ACT_CONNECT) && (!r->connect.port || !get_host_port(&r->connect.addr))) {
1288 ha_alert("config: %s '%s': server '%s' has neither service port nor check port, "
1289 "and a tcp_check rule 'connect' with no port information.\n",
1290 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1291 ret |= ERR_ALERT | ERR_ABORT;
1292 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001293 }
Christopher Faulete5870d82020-04-15 11:32:03 +02001294 }
1295
Christopher Faulet61cc8522020-04-20 14:54:42 +02001296 init:
1297 if (!(srv->proxy->options2 & PR_O2_CHK_ANY)) {
1298 struct tcpcheck_ruleset *rs = NULL;
1299 struct tcpcheck_rules *rules = &srv->proxy->tcpcheck_rules;
1300 //char *errmsg = NULL;
Christopher Faulete5870d82020-04-15 11:32:03 +02001301
Christopher Faulet61cc8522020-04-20 14:54:42 +02001302 srv->proxy->options2 &= ~PR_O2_CHK_ANY;
1303 srv->proxy->options2 |= PR_O2_TCPCHK_CHK;
Christopher Faulete5870d82020-04-15 11:32:03 +02001304
Christopher Faulet61cc8522020-04-20 14:54:42 +02001305 rs = find_tcpcheck_ruleset("*tcp-check");
1306 if (!rs) {
1307 rs = create_tcpcheck_ruleset("*tcp-check");
1308 if (rs == NULL) {
1309 ha_alert("config: %s '%s': out of memory.\n",
1310 proxy_type_str(srv->proxy), srv->proxy->id);
1311 ret |= ERR_ALERT | ERR_FATAL;
1312 goto out;
1313 }
Christopher Faulete5870d82020-04-15 11:32:03 +02001314 }
1315
Christopher Faulet61cc8522020-04-20 14:54:42 +02001316 free_tcpcheck_vars(&rules->preset_vars);
1317 rules->list = &rs->rules;
1318 rules->flags = 0;
Christopher Faulete5870d82020-04-15 11:32:03 +02001319 }
1320
Christopher Faulet61cc8522020-04-20 14:54:42 +02001321 err = init_check(&srv->check, srv->proxy->options2 & PR_O2_CHK_ANY);
1322 if (err) {
1323 ha_alert("config: %s '%s': unable to init check for server '%s' (%s).\n",
1324 proxy_type_str(srv->proxy), srv->proxy->id, srv->id, err);
1325 ret |= ERR_ALERT | ERR_ABORT;
1326 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001327 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001328 srv->check.state |= CHK_ST_CONFIGURED | CHK_ST_ENABLED;
1329 global.maxsock++;
Christopher Faulete5870d82020-04-15 11:32:03 +02001330
Christopher Faulet61cc8522020-04-20 14:54:42 +02001331 out:
1332 return ret;
Christopher Faulete5870d82020-04-15 11:32:03 +02001333}
1334
Christopher Faulet61cc8522020-04-20 14:54:42 +02001335/* Initializes an agent-check attached to the server <srv>. Non-zero is returned
1336 * if an error occurred.
1337 */
1338static int init_srv_agent_check(struct server *srv)
Christopher Faulete5870d82020-04-15 11:32:03 +02001339{
Christopher Faulet61cc8522020-04-20 14:54:42 +02001340 struct tcpcheck_rule *chk;
1341 const char *err;
1342 int ret = 0;
Christopher Faulete5870d82020-04-15 11:32:03 +02001343
Christopher Faulet61cc8522020-04-20 14:54:42 +02001344 if (!srv->do_agent)
1345 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001346
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001347 /* If there is no connect rule preceding all send / expect rules, an
Christopher Faulet61cc8522020-04-20 14:54:42 +02001348 * implicit one is inserted before all others.
1349 */
1350 chk = get_first_tcpcheck_rule(srv->agent.tcpcheck_rules);
1351 if (!chk || chk->action != TCPCHK_ACT_CONNECT) {
1352 chk = calloc(1, sizeof(*chk));
1353 if (!chk) {
1354 ha_alert("config : %s '%s': unable to add implicit tcp-check connect rule"
1355 " to agent-check for server '%s' (out of memory).\n",
1356 proxy_type_str(srv->proxy), srv->proxy->id, srv->id);
1357 ret |= ERR_ALERT | ERR_FATAL;
1358 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001359 }
Christopher Faulet61cc8522020-04-20 14:54:42 +02001360 chk->action = TCPCHK_ACT_CONNECT;
1361 chk->connect.options = (TCPCHK_OPT_DEFAULT_CONNECT|TCPCHK_OPT_IMPLICIT);
1362 LIST_ADD(srv->agent.tcpcheck_rules->list, &chk->list);
Christopher Faulete5870d82020-04-15 11:32:03 +02001363 }
1364
Christopher Faulete5870d82020-04-15 11:32:03 +02001365
Christopher Faulet61cc8522020-04-20 14:54:42 +02001366 err = init_check(&srv->agent, PR_O2_TCPCHK_CHK);
1367 if (err) {
1368 ha_alert("config: %s '%s': unable to init agent-check for server '%s' (%s).\n",
1369 proxy_type_str(srv->proxy), srv->proxy->id, srv->id, err);
1370 ret |= ERR_ALERT | ERR_ABORT;
1371 goto out;
Christopher Faulete5870d82020-04-15 11:32:03 +02001372 }
1373
Christopher Faulet61cc8522020-04-20 14:54:42 +02001374 if (!srv->agent.inter)
1375 srv->agent.inter = srv->check.inter;
1376
1377 srv->agent.state |= CHK_ST_CONFIGURED | CHK_ST_ENABLED | CHK_ST_AGENT;
1378 global.maxsock++;
1379
1380 out:
1381 return ret;
Christopher Faulete5870d82020-04-15 11:32:03 +02001382}
1383
Christopher Faulet61cc8522020-04-20 14:54:42 +02001384static void deinit_srv_check(struct server *srv)
1385{
1386 if (srv->check.state & CHK_ST_CONFIGURED)
1387 free_check(&srv->check);
1388 srv->check.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED;
1389 srv->do_check = 0;
1390}
Christopher Faulete5870d82020-04-15 11:32:03 +02001391
Christopher Faulet61cc8522020-04-20 14:54:42 +02001392
1393static void deinit_srv_agent_check(struct server *srv)
1394{
1395 if (srv->agent.tcpcheck_rules) {
1396 free_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars);
1397 free(srv->agent.tcpcheck_rules);
1398 srv->agent.tcpcheck_rules = NULL;
Christopher Faulete5870d82020-04-15 11:32:03 +02001399 }
Christopher Faulete5870d82020-04-15 11:32:03 +02001400
Christopher Faulet61cc8522020-04-20 14:54:42 +02001401 if (srv->agent.state & CHK_ST_CONFIGURED)
1402 free_check(&srv->agent);
1403
1404 srv->agent.state &= ~CHK_ST_CONFIGURED & ~CHK_ST_ENABLED & ~CHK_ST_AGENT;
1405 srv->do_agent = 0;
Christopher Faulete5870d82020-04-15 11:32:03 +02001406}
1407
Willy Tarreaucee013e2020-06-05 11:40:38 +02001408REGISTER_POST_SERVER_CHECK(init_srv_check);
1409REGISTER_POST_SERVER_CHECK(init_srv_agent_check);
Willy Tarreaucee013e2020-06-05 11:40:38 +02001410REGISTER_POST_CHECK(start_checks);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001411
Willy Tarreaucee013e2020-06-05 11:40:38 +02001412REGISTER_SERVER_DEINIT(deinit_srv_check);
1413REGISTER_SERVER_DEINIT(deinit_srv_agent_check);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001414
Christopher Faulet61cc8522020-04-20 14:54:42 +02001415
1416/**************************************************************************/
1417/************************** Check sample fetches **************************/
1418/**************************************************************************/
Christopher Fauletfd6c2292020-03-25 18:20:15 +01001419
Christopher Faulet61cc8522020-04-20 14:54:42 +02001420static struct sample_fetch_kw_list smp_kws = {ILH, {
Christopher Faulet61cc8522020-04-20 14:54:42 +02001421 { /* END */ },
1422}};
1423
1424INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
1425
1426
1427/**************************************************************************/
1428/************************ Check's parsing functions ***********************/
1429/**************************************************************************/
Christopher Faulet51b129f2020-04-09 15:54:18 +02001430/* Parses the "http-check" proxy keyword */
1431static int proxy_parse_httpcheck(char **args, int section, struct proxy *curpx,
1432 struct proxy *defpx, const char *file, int line,
1433 char **errmsg)
1434{
Christopher Faulete5870d82020-04-15 11:32:03 +02001435 struct tcpcheck_ruleset *rs = NULL;
1436 struct tcpcheck_rule *chk = NULL;
1437 int index, cur_arg, ret = 0;
Christopher Faulet51b129f2020-04-09 15:54:18 +02001438
1439 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[0], NULL))
1440 ret = 1;
1441
1442 cur_arg = 1;
1443 if (strcmp(args[cur_arg], "disable-on-404") == 0) {
1444 /* enable a graceful server shutdown on an HTTP 404 response */
1445 curpx->options |= PR_O_DISABLE404;
1446 if (too_many_args(1, args, errmsg, NULL))
1447 goto error;
Christopher Faulete5870d82020-04-15 11:32:03 +02001448 goto out;
Christopher Faulet51b129f2020-04-09 15:54:18 +02001449 }
1450 else if (strcmp(args[cur_arg], "send-state") == 0) {
1451 /* enable emission of the apparent state of a server in HTTP checks */
1452 curpx->options2 |= PR_O2_CHK_SNDST;
1453 if (too_many_args(1, args, errmsg, NULL))
1454 goto error;
Christopher Faulete5870d82020-04-15 11:32:03 +02001455 goto out;
Christopher Faulet51b129f2020-04-09 15:54:18 +02001456 }
Christopher Faulet51b129f2020-04-09 15:54:18 +02001457
Christopher Faulete5870d82020-04-15 11:32:03 +02001458 /* Deduce the ruleset name from the proxy info */
1459 chunk_printf(&trash, "*http-check-%s_%s-%d",
1460 ((curpx == defpx) ? "defaults" : curpx->id),
1461 curpx->conf.file, curpx->conf.line);
Christopher Faulet51b129f2020-04-09 15:54:18 +02001462
Christopher Faulet61cc8522020-04-20 14:54:42 +02001463 rs = find_tcpcheck_ruleset(b_orig(&trash));
Christopher Faulete5870d82020-04-15 11:32:03 +02001464 if (rs == NULL) {
Christopher Faulet61cc8522020-04-20 14:54:42 +02001465 rs = create_tcpcheck_ruleset(b_orig(&trash));
Christopher Faulete5870d82020-04-15 11:32:03 +02001466 if (rs == NULL) {
1467 memprintf(errmsg, "out of memory.\n");
1468 goto error;
Christopher Faulet51b129f2020-04-09 15:54:18 +02001469 }
1470 }
Christopher Faulet51b129f2020-04-09 15:54:18 +02001471
Christopher Faulete5870d82020-04-15 11:32:03 +02001472 index = 0;
1473 if (!LIST_ISEMPTY(&rs->rules)) {
1474 chk = LIST_PREV(&rs->rules, typeof(chk), list);
1475 if (chk->action != TCPCHK_ACT_SEND || !(chk->send.http.flags & TCPCHK_SND_HTTP_FROM_OPT))
1476 index = chk->index + 1;
1477 }
Christopher Faulet51b129f2020-04-09 15:54:18 +02001478
Christopher Faulete5870d82020-04-15 11:32:03 +02001479 if (strcmp(args[cur_arg], "connect") == 0)
1480 chk = parse_tcpcheck_connect(args, cur_arg, curpx, &rs->rules, file, line, errmsg);
1481 else if (strcmp(args[cur_arg], "send") == 0)
1482 chk = parse_tcpcheck_send_http(args, cur_arg, curpx, &rs->rules, file, line, errmsg);
1483 else if (strcmp(args[cur_arg], "expect") == 0)
1484 chk = parse_tcpcheck_expect(args, cur_arg, curpx, &rs->rules, TCPCHK_RULES_HTTP_CHK,
1485 file, line, errmsg);
1486 else if (strcmp(args[cur_arg], "comment") == 0)
1487 chk = parse_tcpcheck_comment(args, cur_arg, curpx, &rs->rules, file, line, errmsg);
1488 else {
1489 struct action_kw *kw = action_kw_tcp_check_lookup(args[cur_arg]);
Christopher Faulet51b129f2020-04-09 15:54:18 +02001490
Christopher Faulete5870d82020-04-15 11:32:03 +02001491 if (!kw) {
1492 action_kw_tcp_check_build_list(&trash);
1493 memprintf(errmsg, "'%s' only supports 'disable-on-404', 'send-state', 'comment', 'connect',"
1494 " 'send', 'expect'%s%s. but got '%s'",
1495 args[0], (*trash.area ? ", " : ""), trash.area, args[1]);
1496 goto error;
Christopher Faulet51b129f2020-04-09 15:54:18 +02001497 }
Christopher Faulete5870d82020-04-15 11:32:03 +02001498 chk = parse_tcpcheck_action(args, cur_arg, curpx, &rs->rules, kw, file, line, errmsg);
1499 }
Christopher Faulet51b129f2020-04-09 15:54:18 +02001500
Christopher Faulete5870d82020-04-15 11:32:03 +02001501 if (!chk) {
1502 memprintf(errmsg, "'%s %s' : %s.", args[0], args[1], *errmsg);
1503 goto error;
1504 }
1505 ret = (*errmsg != NULL); /* Handle warning */
1506
1507 chk->index = index;
1508 if ((curpx->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
1509 (curpx->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) == TCPCHK_RULES_HTTP_CHK) {
1510 /* Use this ruleset if the proxy already has http-check enabled */
1511 curpx->tcpcheck_rules.list = &rs->rules;
1512 curpx->tcpcheck_rules.flags &= ~TCPCHK_RULES_UNUSED_HTTP_RS;
1513 if (!tcpcheck_add_http_rule(chk, &curpx->tcpcheck_rules, errmsg)) {
1514 memprintf(errmsg, "'%s %s' : %s.", args[0], args[1], *errmsg);
1515 curpx->tcpcheck_rules.list = NULL;
Christopher Faulet51b129f2020-04-09 15:54:18 +02001516 goto error;
1517 }
1518 }
1519 else {
Christopher Faulete5870d82020-04-15 11:32:03 +02001520 /* mark this ruleset as unused for now */
1521 curpx->tcpcheck_rules.flags |= TCPCHK_RULES_UNUSED_HTTP_RS;
1522 LIST_ADDQ(&rs->rules, &chk->list);
Christopher Faulet51b129f2020-04-09 15:54:18 +02001523 }
1524
Christopher Faulete5870d82020-04-15 11:32:03 +02001525 out:
Christopher Faulet51b129f2020-04-09 15:54:18 +02001526 return ret;
1527
1528 error:
Christopher Faulete5870d82020-04-15 11:32:03 +02001529 free_tcpcheck(chk, 0);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001530 free_tcpcheck_ruleset(rs);
Christopher Faulet51b129f2020-04-09 15:54:18 +02001531 return -1;
1532}
1533
Christopher Faulet430e4802020-04-09 15:28:16 +02001534/* Parses the "option tcp-check" proxy keyword */
1535int proxy_parse_tcp_check_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
1536 const char *file, int line)
1537{
Christopher Faulet404f9192020-04-09 23:13:54 +02001538 struct tcpcheck_ruleset *rs = NULL;
Christopher Faulet430e4802020-04-09 15:28:16 +02001539 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
1540 int err_code = 0;
1541
1542 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
1543 err_code |= ERR_WARN;
1544
1545 if (alertif_too_many_args_idx(0, 1, file, line, args, &err_code))
1546 goto out;
1547
Christopher Faulet404f9192020-04-09 23:13:54 +02001548 curpx->options2 &= ~PR_O2_CHK_ANY;
1549 curpx->options2 |= PR_O2_TCPCHK_CHK;
1550
Christopher Fauletd7e63962020-04-17 20:15:59 +02001551 if ((rules->flags & TCPCHK_RULES_PROTO_CHK) == TCPCHK_RULES_TCP_CHK) {
Christopher Faulet404f9192020-04-09 23:13:54 +02001552 /* If a tcp-check rulesset is already set, do nothing */
1553 if (rules->list)
1554 goto out;
1555
1556 /* If a tcp-check ruleset is waiting to be used for the current proxy,
1557 * get it.
1558 */
1559 if (rules->flags & TCPCHK_RULES_UNUSED_TCP_RS)
1560 goto curpx_ruleset;
1561
1562 /* Otherwise, try to get the tcp-check ruleset of the default proxy */
1563 chunk_printf(&trash, "*tcp-check-defaults_%s-%d", defpx->conf.file, defpx->conf.line);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001564 rs = find_tcpcheck_ruleset(b_orig(&trash));
Christopher Faulet404f9192020-04-09 23:13:54 +02001565 if (rs)
1566 goto ruleset_found;
Christopher Faulet430e4802020-04-09 15:28:16 +02001567 }
1568
Christopher Faulet404f9192020-04-09 23:13:54 +02001569 curpx_ruleset:
1570 /* Deduce the ruleset name from the proxy info */
1571 chunk_printf(&trash, "*tcp-check-%s_%s-%d",
1572 ((curpx == defpx) ? "defaults" : curpx->id),
1573 curpx->conf.file, curpx->conf.line);
1574
Christopher Faulet61cc8522020-04-20 14:54:42 +02001575 rs = find_tcpcheck_ruleset(b_orig(&trash));
Christopher Faulet404f9192020-04-09 23:13:54 +02001576 if (rs == NULL) {
Christopher Faulet61cc8522020-04-20 14:54:42 +02001577 rs = create_tcpcheck_ruleset(b_orig(&trash));
Christopher Faulet404f9192020-04-09 23:13:54 +02001578 if (rs == NULL) {
Christopher Faulet430e4802020-04-09 15:28:16 +02001579 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
1580 goto error;
1581 }
Christopher Faulet430e4802020-04-09 15:28:16 +02001582 }
1583
Christopher Faulet404f9192020-04-09 23:13:54 +02001584 ruleset_found:
1585 free_tcpcheck_vars(&rules->preset_vars);
Christopher Faulet404f9192020-04-09 23:13:54 +02001586 rules->list = &rs->rules;
Christopher Fauletd7e63962020-04-17 20:15:59 +02001587 rules->flags |= TCPCHK_RULES_TCP_CHK;
Christopher Faulet430e4802020-04-09 15:28:16 +02001588
1589 out:
1590 return err_code;
1591
1592 error:
1593 err_code |= ERR_ALERT | ERR_FATAL;
1594 goto out;
1595}
Christopher Faulet33f05df2020-04-01 11:08:50 +02001596
1597/* Parses the "option redis-check" proxy keyword */
1598int proxy_parse_redis_check_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
1599 const char *file, int line)
1600{
1601 static char *redis_req = "*1\r\n$4\r\nPING\r\n";
1602 static char *redis_res = "+PONG\r\n";
1603
1604 struct tcpcheck_ruleset *rs = NULL;
1605 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
1606 struct tcpcheck_rule *chk;
1607 char *errmsg = NULL;
1608 int err_code = 0;
1609
1610 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
1611 err_code |= ERR_WARN;
1612
1613 if (alertif_too_many_args_idx(0, 1, file, line, args, &err_code))
1614 goto out;
Christopher Faulet33f05df2020-04-01 11:08:50 +02001615
1616 curpx->options2 &= ~PR_O2_CHK_ANY;
1617 curpx->options2 |= PR_O2_TCPCHK_CHK;
1618
1619 free_tcpcheck_vars(&rules->preset_vars);
1620 rules->list = NULL;
1621 rules->flags = 0;
1622
Christopher Faulet61cc8522020-04-20 14:54:42 +02001623 rs = find_tcpcheck_ruleset("*redis-check");
Christopher Faulet33f05df2020-04-01 11:08:50 +02001624 if (rs)
1625 goto ruleset_found;
1626
Christopher Faulet61cc8522020-04-20 14:54:42 +02001627 rs = create_tcpcheck_ruleset("*redis-check");
Christopher Faulet33f05df2020-04-01 11:08:50 +02001628 if (rs == NULL) {
1629 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
1630 goto error;
1631 }
1632
1633 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send", redis_req, ""},
1634 1, curpx, &rs->rules, file, line, &errmsg);
1635 if (!chk) {
1636 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1637 goto error;
1638 }
1639 chk->index = 0;
1640 LIST_ADDQ(&rs->rules, &chk->list);
1641
1642 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "string", redis_res,
1643 "error-status", "L7STS",
Christopher Faulete596d182020-05-05 17:46:34 +02001644 "on-error", "%[res.payload(0,0),cut_crlf]",
Christopher Faulet33f05df2020-04-01 11:08:50 +02001645 "on-success", "Redis server is ok",
1646 ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02001647 1, curpx, &rs->rules, TCPCHK_RULES_REDIS_CHK, file, line, &errmsg);
Christopher Faulet33f05df2020-04-01 11:08:50 +02001648 if (!chk) {
1649 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1650 goto error;
1651 }
1652 chk->index = 1;
1653 LIST_ADDQ(&rs->rules, &chk->list);
1654
Christopher Faulet33f05df2020-04-01 11:08:50 +02001655 ruleset_found:
1656 rules->list = &rs->rules;
Christopher Faulet404f9192020-04-09 23:13:54 +02001657 rules->flags |= TCPCHK_RULES_REDIS_CHK;
Christopher Faulet33f05df2020-04-01 11:08:50 +02001658
1659 out:
1660 free(errmsg);
1661 return err_code;
1662
1663 error:
Christopher Faulet61cc8522020-04-20 14:54:42 +02001664 free_tcpcheck_ruleset(rs);
Christopher Faulet33f05df2020-04-01 11:08:50 +02001665 err_code |= ERR_ALERT | ERR_FATAL;
1666 goto out;
1667}
1668
Christopher Faulet811f78c2020-04-01 11:10:27 +02001669
1670/* Parses the "option ssl-hello-chk" proxy keyword */
1671int proxy_parse_ssl_hello_chk_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
1672 const char *file, int line)
1673{
1674 /* This is the SSLv3 CLIENT HELLO packet used in conjunction with the
1675 * ssl-hello-chk option to ensure that the remote server speaks SSL.
1676 *
1677 * Check RFC 2246 (TLSv1.0) sections A.3 and A.4 for details.
1678 */
1679 static char sslv3_client_hello[] = {
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001680 "16" /* ContentType : 0x16 = Handshake */
Christopher Faulet811f78c2020-04-01 11:10:27 +02001681 "0300" /* ProtocolVersion : 0x0300 = SSLv3 */
1682 "0079" /* ContentLength : 0x79 bytes after this one */
1683 "01" /* HanshakeType : 0x01 = CLIENT HELLO */
1684 "000075" /* HandshakeLength : 0x75 bytes after this one */
1685 "0300" /* Hello Version : 0x0300 = v3 */
1686 "%[date(),htonl,hex]" /* Unix GMT Time (s) : filled with <now> (@0x0B) */
1687 "%[str(HAPROXYSSLCHK\nHAPROXYSSLCHK\n),hex]" /* Random : must be exactly 28 bytes */
1688 "00" /* Session ID length : empty (no session ID) */
1689 "004E" /* Cipher Suite Length : 78 bytes after this one */
1690 "0001" "0002" "0003" "0004" /* 39 most common ciphers : */
1691 "0005" "0006" "0007" "0008" /* 0x01...0x1B, 0x2F...0x3A */
1692 "0009" "000A" "000B" "000C" /* This covers RSA/DH, */
1693 "000D" "000E" "000F" "0010" /* various bit lengths, */
1694 "0011" "0012" "0013" "0014" /* SHA1/MD5, DES/3DES/AES... */
1695 "0015" "0016" "0017" "0018"
1696 "0019" "001A" "001B" "002F"
1697 "0030" "0031" "0032" "0033"
1698 "0034" "0035" "0036" "0037"
1699 "0038" "0039" "003A"
1700 "01" /* Compression Length : 0x01 = 1 byte for types */
1701 "00" /* Compression Type : 0x00 = NULL compression */
1702 };
1703
1704 struct tcpcheck_ruleset *rs = NULL;
1705 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
1706 struct tcpcheck_rule *chk;
1707 char *errmsg = NULL;
1708 int err_code = 0;
1709
1710 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
1711 err_code |= ERR_WARN;
1712
1713 if (alertif_too_many_args_idx(0, 1, file, line, args, &err_code))
1714 goto out;
1715
Christopher Faulet811f78c2020-04-01 11:10:27 +02001716 curpx->options2 &= ~PR_O2_CHK_ANY;
1717 curpx->options2 |= PR_O2_TCPCHK_CHK;
1718
1719 free_tcpcheck_vars(&rules->preset_vars);
1720 rules->list = NULL;
1721 rules->flags = 0;
1722
Christopher Faulet61cc8522020-04-20 14:54:42 +02001723 rs = find_tcpcheck_ruleset("*ssl-hello-check");
Christopher Faulet811f78c2020-04-01 11:10:27 +02001724 if (rs)
1725 goto ruleset_found;
1726
Christopher Faulet61cc8522020-04-20 14:54:42 +02001727 rs = create_tcpcheck_ruleset("*ssl-hello-check");
Christopher Faulet811f78c2020-04-01 11:10:27 +02001728 if (rs == NULL) {
1729 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
1730 goto error;
1731 }
1732
Christopher Fauletb50b3e62020-05-05 18:43:43 +02001733 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send-binary-lf", sslv3_client_hello, ""},
Christopher Faulet811f78c2020-04-01 11:10:27 +02001734 1, curpx, &rs->rules, file, line, &errmsg);
1735 if (!chk) {
1736 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1737 goto error;
1738 }
1739 chk->index = 0;
1740 LIST_ADDQ(&rs->rules, &chk->list);
1741
1742 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "rbinary", "^1[56]",
Christopher Fauletec07e382020-04-07 14:56:26 +02001743 "min-recv", "5", "ok-status", "L6OK",
Christopher Faulet811f78c2020-04-01 11:10:27 +02001744 "error-status", "L6RSP", "tout-status", "L6TOUT",
1745 ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02001746 1, curpx, &rs->rules, TCPCHK_RULES_SSL3_CHK, file, line, &errmsg);
Christopher Faulet811f78c2020-04-01 11:10:27 +02001747 if (!chk) {
1748 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1749 goto error;
1750 }
1751 chk->index = 1;
1752 LIST_ADDQ(&rs->rules, &chk->list);
1753
Christopher Faulet811f78c2020-04-01 11:10:27 +02001754 ruleset_found:
1755 rules->list = &rs->rules;
Christopher Faulet404f9192020-04-09 23:13:54 +02001756 rules->flags |= TCPCHK_RULES_SSL3_CHK;
Christopher Faulet811f78c2020-04-01 11:10:27 +02001757
1758 out:
1759 free(errmsg);
1760 return err_code;
1761
1762 error:
Christopher Faulet61cc8522020-04-20 14:54:42 +02001763 free_tcpcheck_ruleset(rs);
Christopher Faulet811f78c2020-04-01 11:10:27 +02001764 err_code |= ERR_ALERT | ERR_FATAL;
1765 goto out;
1766}
1767
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001768/* Parses the "option smtpchk" proxy keyword */
1769int proxy_parse_smtpchk_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
1770 const char *file, int line)
1771{
1772 static char *smtp_req = "%[var(check.smtp_cmd)]\r\n";
1773
1774 struct tcpcheck_ruleset *rs = NULL;
1775 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
1776 struct tcpcheck_rule *chk;
1777 struct tcpcheck_var *var = NULL;
1778 char *cmd = NULL, *errmsg = NULL;
1779 int err_code = 0;
1780
1781 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
1782 err_code |= ERR_WARN;
1783
1784 if (alertif_too_many_args_idx(2, 1, file, line, args, &err_code))
1785 goto out;
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001786
1787 curpx->options2 &= ~PR_O2_CHK_ANY;
1788 curpx->options2 |= PR_O2_TCPCHK_CHK;
1789
1790 free_tcpcheck_vars(&rules->preset_vars);
1791 rules->list = NULL;
1792 rules->flags = 0;
1793
1794 cur_arg += 2;
1795 if (*args[cur_arg] && *args[cur_arg+1] &&
1796 (strcmp(args[cur_arg], "EHLO") == 0 || strcmp(args[cur_arg], "HELO") == 0)) {
Tim Duesterhus2867b402020-06-12 15:58:48 +02001797 /* <EHLO|HELO> + space (1) + <host> + null byte (1) */
1798 cmd = calloc(strlen(args[cur_arg]) + 1 + strlen(args[cur_arg+1]) + 1, sizeof(*cmd));
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001799 if (cmd)
1800 sprintf(cmd, "%s %s", args[cur_arg], args[cur_arg+1]);
1801 }
1802 else {
1803 /* this just hits the default for now, but you could potentially expand it to allow for other stuff
1804 though, it's unlikely you'd want to send anything other than an EHLO or HELO */
1805 cmd = strdup("HELO localhost");
1806 }
1807
Christopher Fauletb61caf42020-04-21 10:57:42 +02001808 var = create_tcpcheck_var(ist("check.smtp_cmd"));
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001809 if (cmd == NULL || var == NULL) {
1810 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
1811 goto error;
1812 }
1813 var->data.type = SMP_T_STR;
1814 var->data.u.str.area = cmd;
1815 var->data.u.str.data = strlen(cmd);
1816 LIST_INIT(&var->list);
1817 LIST_ADDQ(&rules->preset_vars, &var->list);
1818 cmd = NULL;
1819 var = NULL;
1820
Christopher Faulet61cc8522020-04-20 14:54:42 +02001821 rs = find_tcpcheck_ruleset("*smtp-check");
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001822 if (rs)
1823 goto ruleset_found;
1824
Christopher Faulet61cc8522020-04-20 14:54:42 +02001825 rs = create_tcpcheck_ruleset("*smtp-check");
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001826 if (rs == NULL) {
1827 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
1828 goto error;
1829 }
1830
1831 chk = parse_tcpcheck_connect((char *[]){"tcp-check", "connect", "default", "linger", ""},
1832 1, curpx, &rs->rules, file, line, &errmsg);
1833 if (!chk) {
1834 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1835 goto error;
1836 }
1837 chk->index = 0;
1838 LIST_ADDQ(&rs->rules, &chk->list);
1839
1840 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "rstring", "^[0-9]{3}[ \r]",
1841 "min-recv", "4",
1842 "error-status", "L7RSP",
Christopher Faulete596d182020-05-05 17:46:34 +02001843 "on-error", "%[res.payload(0,0),cut_crlf]",
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001844 ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02001845 1, curpx, &rs->rules, TCPCHK_RULES_SMTP_CHK, file, line, &errmsg);
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001846 if (!chk) {
1847 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1848 goto error;
1849 }
1850 chk->index = 1;
1851 LIST_ADDQ(&rs->rules, &chk->list);
1852
1853 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "rstring", "^2[0-9]{2}[ \r]",
1854 "min-recv", "4",
1855 "error-status", "L7STS",
Christopher Faulete596d182020-05-05 17:46:34 +02001856 "on-error", "%[res.payload(4,0),ltrim(' '),cut_crlf]",
1857 "status-code", "res.payload(0,3)",
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001858 ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02001859 1, curpx, &rs->rules, TCPCHK_RULES_SMTP_CHK, file, line, &errmsg);
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001860 if (!chk) {
1861 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1862 goto error;
1863 }
1864 chk->index = 2;
1865 LIST_ADDQ(&rs->rules, &chk->list);
1866
Christopher Fauletb50b3e62020-05-05 18:43:43 +02001867 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send-lf", smtp_req, ""},
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001868 1, curpx, &rs->rules, file, line, &errmsg);
1869 if (!chk) {
1870 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1871 goto error;
1872 }
1873 chk->index = 3;
1874 LIST_ADDQ(&rs->rules, &chk->list);
1875
1876 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "rstring", "^2[0-9]{2}[- \r]",
1877 "min-recv", "4",
1878 "error-status", "L7STS",
Christopher Faulete596d182020-05-05 17:46:34 +02001879 "on-error", "%[res.payload(4,0),ltrim(' '),cut_crlf]",
1880 "on-success", "%[res.payload(4,0),ltrim(' '),cut_crlf]",
1881 "status-code", "res.payload(0,3)",
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001882 ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02001883 1, curpx, &rs->rules, TCPCHK_RULES_SMTP_CHK, file, line, &errmsg);
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001884 if (!chk) {
1885 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1886 goto error;
1887 }
1888 chk->index = 4;
1889 LIST_ADDQ(&rs->rules, &chk->list);
1890
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001891 ruleset_found:
1892 rules->list = &rs->rules;
Christopher Faulet404f9192020-04-09 23:13:54 +02001893 rules->flags |= TCPCHK_RULES_SMTP_CHK;
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001894
1895 out:
1896 free(errmsg);
1897 return err_code;
1898
1899 error:
1900 free(cmd);
1901 free(var);
1902 free_tcpcheck_vars(&rules->preset_vars);
Christopher Faulet61cc8522020-04-20 14:54:42 +02001903 free_tcpcheck_ruleset(rs);
Christopher Fauletfbcc77c2020-04-01 20:54:05 +02001904 err_code |= ERR_ALERT | ERR_FATAL;
1905 goto out;
1906}
Christopher Faulet811f78c2020-04-01 11:10:27 +02001907
Christopher Fauletce355072020-04-02 11:44:39 +02001908/* Parses the "option pgsql-check" proxy keyword */
1909int proxy_parse_pgsql_check_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
1910 const char *file, int line)
1911{
1912 static char pgsql_req[] = {
1913 "%[var(check.plen),htonl,hex]" /* The packet length*/
1914 "00030000" /* the version 3.0 */
1915 "7573657200" /* "user" key */
1916 "%[var(check.username),hex]00" /* the username */
1917 "00"
1918 };
1919
1920 struct tcpcheck_ruleset *rs = NULL;
1921 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
1922 struct tcpcheck_rule *chk;
1923 struct tcpcheck_var *var = NULL;
1924 char *user = NULL, *errmsg = NULL;
1925 size_t packetlen = 0;
1926 int err_code = 0;
1927
1928 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
1929 err_code |= ERR_WARN;
1930
1931 if (alertif_too_many_args_idx(2, 1, file, line, args, &err_code))
1932 goto out;
1933
Christopher Fauletce355072020-04-02 11:44:39 +02001934 curpx->options2 &= ~PR_O2_CHK_ANY;
1935 curpx->options2 |= PR_O2_TCPCHK_CHK;
1936
1937 free_tcpcheck_vars(&rules->preset_vars);
1938 rules->list = NULL;
1939 rules->flags = 0;
1940
1941 cur_arg += 2;
1942 if (!*args[cur_arg] || !*args[cur_arg+1]) {
1943 ha_alert("parsing [%s:%d] : '%s %s' expects 'user <username>' as argument.\n",
1944 file, line, args[0], args[1]);
1945 goto error;
1946 }
1947 if (strcmp(args[cur_arg], "user") == 0) {
1948 packetlen = 15 + strlen(args[cur_arg+1]);
1949 user = strdup(args[cur_arg+1]);
1950
Christopher Fauletb61caf42020-04-21 10:57:42 +02001951 var = create_tcpcheck_var(ist("check.username"));
Christopher Fauletce355072020-04-02 11:44:39 +02001952 if (user == NULL || var == NULL) {
1953 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
1954 goto error;
1955 }
1956 var->data.type = SMP_T_STR;
1957 var->data.u.str.area = user;
1958 var->data.u.str.data = strlen(user);
1959 LIST_INIT(&var->list);
1960 LIST_ADDQ(&rules->preset_vars, &var->list);
1961 user = NULL;
1962 var = NULL;
1963
Christopher Fauletb61caf42020-04-21 10:57:42 +02001964 var = create_tcpcheck_var(ist("check.plen"));
Christopher Fauletce355072020-04-02 11:44:39 +02001965 if (var == NULL) {
1966 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
1967 goto error;
1968 }
1969 var->data.type = SMP_T_SINT;
1970 var->data.u.sint = packetlen;
1971 LIST_INIT(&var->list);
1972 LIST_ADDQ(&rules->preset_vars, &var->list);
1973 var = NULL;
1974 }
1975 else {
1976 ha_alert("parsing [%s:%d] : '%s %s' only supports optional values: 'user'.\n",
1977 file, line, args[0], args[1]);
1978 goto error;
1979 }
1980
Christopher Faulet61cc8522020-04-20 14:54:42 +02001981 rs = find_tcpcheck_ruleset("*pgsql-check");
Christopher Fauletce355072020-04-02 11:44:39 +02001982 if (rs)
1983 goto ruleset_found;
1984
Christopher Faulet61cc8522020-04-20 14:54:42 +02001985 rs = create_tcpcheck_ruleset("*pgsql-check");
Christopher Fauletce355072020-04-02 11:44:39 +02001986 if (rs == NULL) {
1987 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
1988 goto error;
1989 }
1990
1991 chk = parse_tcpcheck_connect((char *[]){"tcp-check", "connect", "default", "linger", ""},
1992 1, curpx, &rs->rules, file, line, &errmsg);
1993 if (!chk) {
1994 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
1995 goto error;
1996 }
1997 chk->index = 0;
1998 LIST_ADDQ(&rs->rules, &chk->list);
1999
Christopher Fauletb50b3e62020-05-05 18:43:43 +02002000 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send-binary-lf", pgsql_req, ""},
Christopher Fauletce355072020-04-02 11:44:39 +02002001 1, curpx, &rs->rules, file, line, &errmsg);
2002 if (!chk) {
2003 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2004 goto error;
2005 }
2006 chk->index = 1;
2007 LIST_ADDQ(&rs->rules, &chk->list);
2008
2009 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "!rstring", "^E",
2010 "min-recv", "5",
2011 "error-status", "L7RSP",
Christopher Faulete596d182020-05-05 17:46:34 +02002012 "on-error", "%[res.payload(6,0)]",
Christopher Fauletce355072020-04-02 11:44:39 +02002013 ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02002014 1, curpx, &rs->rules, TCPCHK_RULES_PGSQL_CHK, file, line, &errmsg);
Christopher Fauletce355072020-04-02 11:44:39 +02002015 if (!chk) {
2016 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2017 goto error;
2018 }
2019 chk->index = 2;
2020 LIST_ADDQ(&rs->rules, &chk->list);
2021
Christopher Fauletb841c742020-04-27 18:29:49 +02002022 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "rbinary", "^52000000(08|0A|0C)000000(00|02|03|04|05|06)",
Christopher Fauletce355072020-04-02 11:44:39 +02002023 "min-recv", "9",
2024 "error-status", "L7STS",
2025 "on-success", "PostgreSQL server is ok",
2026 "on-error", "PostgreSQL unknown error",
2027 ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02002028 1, curpx, &rs->rules, TCPCHK_RULES_PGSQL_CHK, file, line, &errmsg);
Christopher Fauletce355072020-04-02 11:44:39 +02002029 if (!chk) {
2030 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2031 goto error;
2032 }
2033 chk->index = 3;
2034 LIST_ADDQ(&rs->rules, &chk->list);
2035
Christopher Fauletce355072020-04-02 11:44:39 +02002036 ruleset_found:
2037 rules->list = &rs->rules;
Christopher Faulet404f9192020-04-09 23:13:54 +02002038 rules->flags |= TCPCHK_RULES_PGSQL_CHK;
Christopher Fauletce355072020-04-02 11:44:39 +02002039
2040 out:
2041 free(errmsg);
2042 return err_code;
2043
2044 error:
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002045 free(user);
2046 free(var);
2047 free_tcpcheck_vars(&rules->preset_vars);
Christopher Faulet61cc8522020-04-20 14:54:42 +02002048 free_tcpcheck_ruleset(rs);
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002049 err_code |= ERR_ALERT | ERR_FATAL;
2050 goto out;
2051}
2052
2053
2054/* Parses the "option mysql-check" proxy keyword */
2055int proxy_parse_mysql_check_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
2056 const char *file, int line)
2057{
2058 /* This is an example of a MySQL >=4.0 client Authentication packet kindly provided by Cyril Bonte.
2059 * const char mysql40_client_auth_pkt[] = {
2060 * "\x0e\x00\x00" // packet length
2061 * "\x01" // packet number
2062 * "\x00\x00" // client capabilities
2063 * "\x00\x00\x01" // max packet
2064 * "haproxy\x00" // username (null terminated string)
2065 * "\x00" // filler (always 0x00)
2066 * "\x01\x00\x00" // packet length
2067 * "\x00" // packet number
2068 * "\x01" // COM_QUIT command
2069 * };
2070 */
2071 static char mysql40_rsname[] = "*mysql40-check";
2072 static char mysql40_req[] = {
2073 "%[var(check.header),hex]" /* 3 bytes for the packet length and 1 byte for the sequence ID */
2074 "0080" /* client capabilities */
2075 "000001" /* max packet */
2076 "%[var(check.username),hex]00" /* the username */
2077 "00" /* filler (always 0x00) */
2078 "010000" /* packet length*/
2079 "00" /* sequence ID */
2080 "01" /* COM_QUIT command */
2081 };
2082
2083 /* This is an example of a MySQL >=4.1 client Authentication packet provided by Nenad Merdanovic.
2084 * const char mysql41_client_auth_pkt[] = {
2085 * "\x0e\x00\x00\" // packet length
2086 * "\x01" // packet number
2087 * "\x00\x00\x00\x00" // client capabilities
2088 * "\x00\x00\x00\x01" // max packet
2089 * "\x21" // character set (UTF-8)
2090 * char[23] // All zeroes
2091 * "haproxy\x00" // username (null terminated string)
2092 * "\x00" // filler (always 0x00)
2093 * "\x01\x00\x00" // packet length
2094 * "\x00" // packet number
2095 * "\x01" // COM_QUIT command
2096 * };
2097 */
2098 static char mysql41_rsname[] = "*mysql41-check";
2099 static char mysql41_req[] = {
2100 "%[var(check.header),hex]" /* 3 bytes for the packet length and 1 byte for the sequence ID */
2101 "00820000" /* client capabilities */
2102 "00800001" /* max packet */
2103 "21" /* character set (UTF-8) */
2104 "000000000000000000000000" /* 23 bytes, al zeroes */
2105 "0000000000000000000000"
2106 "%[var(check.username),hex]00" /* the username */
2107 "00" /* filler (always 0x00) */
2108 "010000" /* packet length*/
2109 "00" /* sequence ID */
2110 "01" /* COM_QUIT command */
2111 };
2112
2113 struct tcpcheck_ruleset *rs = NULL;
2114 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
2115 struct tcpcheck_rule *chk;
2116 struct tcpcheck_var *var = NULL;
2117 char *mysql_rsname = "*mysql-check";
2118 char *mysql_req = NULL, *hdr = NULL, *user = NULL, *errmsg = NULL;
2119 int index = 0, err_code = 0;
2120
2121 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
2122 err_code |= ERR_WARN;
2123
2124 if (alertif_too_many_args_idx(3, 1, file, line, args, &err_code))
2125 goto out;
2126
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002127 curpx->options2 &= ~PR_O2_CHK_ANY;
2128 curpx->options2 |= PR_O2_TCPCHK_CHK;
2129
2130 free_tcpcheck_vars(&rules->preset_vars);
2131 rules->list = NULL;
2132 rules->flags = 0;
2133
2134 cur_arg += 2;
2135 if (*args[cur_arg]) {
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002136 int packetlen, userlen;
2137
2138 if (strcmp(args[cur_arg], "user") != 0) {
2139 ha_alert("parsing [%s:%d] : '%s %s' only supports optional values: 'user' (got '%s').\n",
2140 file, line, args[0], args[1], args[cur_arg]);
2141 goto error;
2142 }
2143
2144 if (*(args[cur_arg+1]) == 0) {
2145 ha_alert("parsing [%s:%d] : '%s %s %s' expects <username> as argument.\n",
2146 file, line, args[0], args[1], args[cur_arg]);
2147 goto error;
2148 }
2149
2150 hdr = calloc(4, sizeof(*hdr));
2151 user = strdup(args[cur_arg+1]);
2152 userlen = strlen(args[cur_arg+1]);
2153
2154 if (hdr == NULL || user == NULL) {
2155 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
2156 goto error;
2157 }
2158
Christopher Faulet62f79fe2020-05-18 18:13:03 +02002159 if (!*args[cur_arg+2] || strcmp(args[cur_arg+2], "post-41") == 0) {
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002160 packetlen = userlen + 7 + 27;
2161 mysql_req = mysql41_req;
2162 mysql_rsname = mysql41_rsname;
2163 }
Christopher Faulet62f79fe2020-05-18 18:13:03 +02002164 else if (strcmp(args[cur_arg+2], "pre-41") == 0) {
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002165 packetlen = userlen + 7;
2166 mysql_req = mysql40_req;
2167 mysql_rsname = mysql40_rsname;
2168 }
Christopher Faulet62f79fe2020-05-18 18:13:03 +02002169 else {
2170 ha_alert("parsing [%s:%d] : keyword '%s' only supports 'post-41' and 'pre-41' (got '%s').\n",
2171 file, line, args[cur_arg], args[cur_arg+2]);
2172 goto error;
2173 }
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002174
2175 hdr[0] = (unsigned char)(packetlen & 0xff);
2176 hdr[1] = (unsigned char)((packetlen >> 8) & 0xff);
2177 hdr[2] = (unsigned char)((packetlen >> 16) & 0xff);
2178 hdr[3] = 1;
2179
Christopher Fauletb61caf42020-04-21 10:57:42 +02002180 var = create_tcpcheck_var(ist("check.header"));
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002181 if (var == NULL) {
2182 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
2183 goto error;
2184 }
2185 var->data.type = SMP_T_STR;
2186 var->data.u.str.area = hdr;
2187 var->data.u.str.data = 4;
2188 LIST_INIT(&var->list);
2189 LIST_ADDQ(&rules->preset_vars, &var->list);
2190 hdr = NULL;
2191 var = NULL;
2192
Christopher Fauletb61caf42020-04-21 10:57:42 +02002193 var = create_tcpcheck_var(ist("check.username"));
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002194 if (var == NULL) {
2195 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
2196 goto error;
2197 }
2198 var->data.type = SMP_T_STR;
2199 var->data.u.str.area = user;
2200 var->data.u.str.data = strlen(user);
2201 LIST_INIT(&var->list);
2202 LIST_ADDQ(&rules->preset_vars, &var->list);
2203 user = NULL;
2204 var = NULL;
2205 }
2206
Christopher Faulet61cc8522020-04-20 14:54:42 +02002207 rs = find_tcpcheck_ruleset(mysql_rsname);
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002208 if (rs)
2209 goto ruleset_found;
2210
Christopher Faulet61cc8522020-04-20 14:54:42 +02002211 rs = create_tcpcheck_ruleset(mysql_rsname);
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002212 if (rs == NULL) {
2213 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
2214 goto error;
2215 }
2216
2217 chk = parse_tcpcheck_connect((char *[]){"tcp-check", "connect", "default", "linger", ""},
2218 1, curpx, &rs->rules, file, line, &errmsg);
2219 if (!chk) {
2220 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2221 goto error;
2222 }
2223 chk->index = index++;
2224 LIST_ADDQ(&rs->rules, &chk->list);
2225
2226 if (mysql_req) {
Christopher Fauletb50b3e62020-05-05 18:43:43 +02002227 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send-binary-lf", mysql_req, ""},
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002228 1, curpx, &rs->rules, file, line, &errmsg);
2229 if (!chk) {
2230 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2231 goto error;
2232 }
2233 chk->index = index++;
2234 LIST_ADDQ(&rs->rules, &chk->list);
2235 }
2236
2237 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "custom", ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02002238 1, curpx, &rs->rules, TCPCHK_RULES_MYSQL_CHK, file, line, &errmsg);
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002239 if (!chk) {
2240 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2241 goto error;
2242 }
2243 chk->expect.custom = tcpcheck_mysql_expect_iniths;
2244 chk->index = index++;
2245 LIST_ADDQ(&rs->rules, &chk->list);
2246
2247 if (mysql_req) {
2248 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "custom", ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02002249 1, curpx, &rs->rules, TCPCHK_RULES_MYSQL_CHK, file, line, &errmsg);
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002250 if (!chk) {
2251 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2252 goto error;
2253 }
2254 chk->expect.custom = tcpcheck_mysql_expect_ok;
2255 chk->index = index++;
2256 LIST_ADDQ(&rs->rules, &chk->list);
2257 }
2258
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002259 ruleset_found:
2260 rules->list = &rs->rules;
Christopher Faulet404f9192020-04-09 23:13:54 +02002261 rules->flags |= TCPCHK_RULES_MYSQL_CHK;
Christopher Fauletf2b3be52020-04-02 18:07:37 +02002262
2263 out:
2264 free(errmsg);
2265 return err_code;
2266
2267 error:
2268 free(hdr);
Christopher Fauletce355072020-04-02 11:44:39 +02002269 free(user);
2270 free(var);
2271 free_tcpcheck_vars(&rules->preset_vars);
Christopher Faulet61cc8522020-04-20 14:54:42 +02002272 free_tcpcheck_ruleset(rs);
Christopher Fauletce355072020-04-02 11:44:39 +02002273 err_code |= ERR_ALERT | ERR_FATAL;
2274 goto out;
2275}
2276
Christopher Faulet1997eca2020-04-03 23:13:50 +02002277int proxy_parse_ldap_check_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
2278 const char *file, int line)
2279{
2280 static char *ldap_req = "300C020101600702010304008000";
2281
2282 struct tcpcheck_ruleset *rs = NULL;
2283 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
2284 struct tcpcheck_rule *chk;
2285 char *errmsg = NULL;
2286 int err_code = 0;
2287
2288 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
2289 err_code |= ERR_WARN;
2290
2291 if (alertif_too_many_args_idx(0, 1, file, line, args, &err_code))
2292 goto out;
Christopher Faulet1997eca2020-04-03 23:13:50 +02002293
2294 curpx->options2 &= ~PR_O2_CHK_ANY;
2295 curpx->options2 |= PR_O2_TCPCHK_CHK;
2296
2297 free_tcpcheck_vars(&rules->preset_vars);
2298 rules->list = NULL;
2299 rules->flags = 0;
2300
Christopher Faulet61cc8522020-04-20 14:54:42 +02002301 rs = find_tcpcheck_ruleset("*ldap-check");
Christopher Faulet1997eca2020-04-03 23:13:50 +02002302 if (rs)
2303 goto ruleset_found;
2304
Christopher Faulet61cc8522020-04-20 14:54:42 +02002305 rs = create_tcpcheck_ruleset("*ldap-check");
Christopher Faulet1997eca2020-04-03 23:13:50 +02002306 if (rs == NULL) {
2307 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
2308 goto error;
2309 }
2310
2311 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send-binary", ldap_req, ""},
2312 1, curpx, &rs->rules, file, line, &errmsg);
2313 if (!chk) {
2314 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2315 goto error;
2316 }
2317 chk->index = 0;
2318 LIST_ADDQ(&rs->rules, &chk->list);
2319
2320 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "rbinary", "^30",
2321 "min-recv", "14",
2322 "on-error", "Not LDAPv3 protocol",
2323 ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02002324 1, curpx, &rs->rules, TCPCHK_RULES_LDAP_CHK, file, line, &errmsg);
Christopher Faulet1997eca2020-04-03 23:13:50 +02002325 if (!chk) {
2326 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2327 goto error;
2328 }
2329 chk->index = 1;
2330 LIST_ADDQ(&rs->rules, &chk->list);
2331
2332 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "custom", ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02002333 1, curpx, &rs->rules, TCPCHK_RULES_LDAP_CHK, file, line, &errmsg);
Christopher Faulet1997eca2020-04-03 23:13:50 +02002334 if (!chk) {
2335 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2336 goto error;
2337 }
2338 chk->expect.custom = tcpcheck_ldap_expect_bindrsp;
2339 chk->index = 2;
2340 LIST_ADDQ(&rs->rules, &chk->list);
2341
Christopher Faulet1997eca2020-04-03 23:13:50 +02002342 ruleset_found:
2343 rules->list = &rs->rules;
Christopher Faulet404f9192020-04-09 23:13:54 +02002344 rules->flags |= TCPCHK_RULES_LDAP_CHK;
Christopher Faulet1997eca2020-04-03 23:13:50 +02002345
2346 out:
Christopher Faulet267b01b2020-04-04 10:27:09 +02002347 free(errmsg);
2348 return err_code;
2349
2350 error:
Christopher Faulet61cc8522020-04-20 14:54:42 +02002351 free_tcpcheck_ruleset(rs);
Christopher Faulet267b01b2020-04-04 10:27:09 +02002352 err_code |= ERR_ALERT | ERR_FATAL;
2353 goto out;
2354}
2355
2356int proxy_parse_spop_check_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
2357 const char *file, int line)
2358{
2359 struct tcpcheck_ruleset *rs = NULL;
2360 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
2361 struct tcpcheck_rule *chk;
2362 char *spop_req = NULL;
2363 char *errmsg = NULL;
2364 int spop_len = 0, err_code = 0;
2365
2366 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
2367 err_code |= ERR_WARN;
2368
2369 if (alertif_too_many_args_idx(0, 1, file, line, args, &err_code))
2370 goto out;
2371
Christopher Faulet267b01b2020-04-04 10:27:09 +02002372 curpx->options2 &= ~PR_O2_CHK_ANY;
2373 curpx->options2 |= PR_O2_TCPCHK_CHK;
2374
2375 free_tcpcheck_vars(&rules->preset_vars);
2376 rules->list = NULL;
2377 rules->flags = 0;
2378
2379
Christopher Faulet61cc8522020-04-20 14:54:42 +02002380 rs = find_tcpcheck_ruleset("*spop-check");
Christopher Faulet267b01b2020-04-04 10:27:09 +02002381 if (rs)
2382 goto ruleset_found;
2383
Christopher Faulet61cc8522020-04-20 14:54:42 +02002384 rs = create_tcpcheck_ruleset("*spop-check");
Christopher Faulet267b01b2020-04-04 10:27:09 +02002385 if (rs == NULL) {
2386 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
2387 goto error;
2388 }
2389
2390 if (spoe_prepare_healthcheck_request(&spop_req, &spop_len) == -1) {
2391 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
2392 goto error;
2393 }
2394 chunk_reset(&trash);
2395 dump_binary(&trash, spop_req, spop_len);
2396 trash.area[trash.data] = '\0';
2397
2398 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send-binary", b_head(&trash), ""},
2399 1, curpx, &rs->rules, file, line, &errmsg);
2400 if (!chk) {
2401 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2402 goto error;
2403 }
2404 chk->index = 0;
2405 LIST_ADDQ(&rs->rules, &chk->list);
2406
2407 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "custom", "min-recv", "4", ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02002408 1, curpx, &rs->rules, TCPCHK_RULES_SPOP_CHK, file, line, &errmsg);
Christopher Faulet267b01b2020-04-04 10:27:09 +02002409 if (!chk) {
2410 ha_alert("parsing [%s:%d] : %s\n", file, line, errmsg);
2411 goto error;
2412 }
2413 chk->expect.custom = tcpcheck_spop_expect_agenthello;
2414 chk->index = 1;
2415 LIST_ADDQ(&rs->rules, &chk->list);
2416
Christopher Faulet267b01b2020-04-04 10:27:09 +02002417 ruleset_found:
2418 rules->list = &rs->rules;
Christopher Faulet404f9192020-04-09 23:13:54 +02002419 rules->flags |= TCPCHK_RULES_SPOP_CHK;
Christopher Faulet267b01b2020-04-04 10:27:09 +02002420
2421 out:
2422 free(spop_req);
Christopher Faulet1997eca2020-04-03 23:13:50 +02002423 free(errmsg);
2424 return err_code;
2425
2426 error:
Christopher Faulet61cc8522020-04-20 14:54:42 +02002427 free_tcpcheck_ruleset(rs);
Christopher Faulet1997eca2020-04-03 23:13:50 +02002428 err_code |= ERR_ALERT | ERR_FATAL;
2429 goto out;
2430}
Christopher Fauletce355072020-04-02 11:44:39 +02002431
Christopher Faulete5870d82020-04-15 11:32:03 +02002432
2433struct tcpcheck_rule *proxy_parse_httpchk_req(char **args, int cur_arg, struct proxy *px, char **errmsg)
2434{
2435 struct tcpcheck_rule *chk = NULL;
2436 struct tcpcheck_http_hdr *hdr = NULL;
2437 char *meth = NULL, *uri = NULL, *vsn = NULL;
2438 char *hdrs, *body;
2439
2440 hdrs = (*args[cur_arg+2] ? strstr(args[cur_arg+2], "\r\n") : NULL);
2441 body = (*args[cur_arg+2] ? strstr(args[cur_arg+2], "\r\n\r\n") : NULL);
2442 if (hdrs == body)
2443 hdrs = NULL;
2444 if (hdrs) {
2445 *hdrs = '\0';
2446 hdrs +=2;
2447 }
2448 if (body) {
2449 *body = '\0';
2450 body += 4;
2451 }
2452 if (hdrs || body) {
2453 memprintf(errmsg, "hiding headers or body at the end of the version string is deprecated."
2454 " Please, consider to use 'http-check send' directive instead.");
2455 }
2456
2457 chk = calloc(1, sizeof(*chk));
2458 if (!chk) {
2459 memprintf(errmsg, "out of memory");
2460 goto error;
2461 }
2462 chk->action = TCPCHK_ACT_SEND;
2463 chk->send.type = TCPCHK_SEND_HTTP;
2464 chk->send.http.flags |= TCPCHK_SND_HTTP_FROM_OPT;
2465 chk->send.http.meth.meth = HTTP_METH_OPTIONS;
2466 LIST_INIT(&chk->send.http.hdrs);
2467
2468 /* Copy the method, uri and version */
2469 if (*args[cur_arg]) {
2470 if (!*args[cur_arg+1])
2471 uri = args[cur_arg];
2472 else
2473 meth = args[cur_arg];
2474 }
2475 if (*args[cur_arg+1])
2476 uri = args[cur_arg+1];
2477 if (*args[cur_arg+2])
2478 vsn = args[cur_arg+2];
2479
2480 if (meth) {
2481 chk->send.http.meth.meth = find_http_meth(meth, strlen(meth));
2482 chk->send.http.meth.str.area = strdup(meth);
2483 chk->send.http.meth.str.data = strlen(meth);
2484 if (!chk->send.http.meth.str.area) {
2485 memprintf(errmsg, "out of memory");
2486 goto error;
2487 }
2488 }
2489 if (uri) {
2490 chk->send.http.uri = ist2(strdup(uri), strlen(uri));
Christopher Fauletb61caf42020-04-21 10:57:42 +02002491 if (!isttest(chk->send.http.uri)) {
Christopher Faulete5870d82020-04-15 11:32:03 +02002492 memprintf(errmsg, "out of memory");
2493 goto error;
2494 }
2495 }
2496 if (vsn) {
2497 chk->send.http.vsn = ist2(strdup(vsn), strlen(vsn));
Christopher Fauletb61caf42020-04-21 10:57:42 +02002498 if (!isttest(chk->send.http.vsn)) {
Christopher Faulete5870d82020-04-15 11:32:03 +02002499 memprintf(errmsg, "out of memory");
2500 goto error;
2501 }
2502 }
2503
2504 /* Copy the header */
2505 if (hdrs) {
2506 struct http_hdr tmp_hdrs[global.tune.max_http_hdr];
2507 struct h1m h1m;
2508 int i, ret;
2509
2510 /* Build and parse the request */
2511 chunk_printf(&trash, "%s\r\n\r\n", hdrs);
2512
2513 h1m.flags = H1_MF_HDRS_ONLY;
2514 ret = h1_headers_to_hdr_list(b_orig(&trash), b_tail(&trash),
2515 tmp_hdrs, sizeof(tmp_hdrs)/sizeof(tmp_hdrs[0]),
2516 &h1m, NULL);
2517 if (ret <= 0) {
2518 memprintf(errmsg, "unable to parse the request '%s'.", b_orig(&trash));
2519 goto error;
2520 }
2521
Christopher Fauletb61caf42020-04-21 10:57:42 +02002522 for (i = 0; istlen(tmp_hdrs[i].n); i++) {
Christopher Faulete5870d82020-04-15 11:32:03 +02002523 hdr = calloc(1, sizeof(*hdr));
2524 if (!hdr) {
2525 memprintf(errmsg, "out of memory");
2526 goto error;
2527 }
2528 LIST_INIT(&hdr->value);
Christopher Fauletb61caf42020-04-21 10:57:42 +02002529 hdr->name = istdup(tmp_hdrs[i].n);
Christopher Faulete5870d82020-04-15 11:32:03 +02002530 if (!hdr->name.ptr) {
2531 memprintf(errmsg, "out of memory");
2532 goto error;
2533 }
2534
Christopher Fauletb61caf42020-04-21 10:57:42 +02002535 ist0(tmp_hdrs[i].v);
2536 if (!parse_logformat_string(istptr(tmp_hdrs[i].v), px, &hdr->value, 0, SMP_VAL_BE_CHK_RUL, errmsg))
Christopher Faulete5870d82020-04-15 11:32:03 +02002537 goto error;
2538 LIST_ADDQ(&chk->send.http.hdrs, &hdr->list);
2539 }
2540 }
2541
2542 /* Copy the body */
2543 if (body) {
2544 chk->send.http.body = ist2(strdup(body), strlen(body));
Christopher Fauletb61caf42020-04-21 10:57:42 +02002545 if (!isttest(chk->send.http.body)) {
Christopher Faulete5870d82020-04-15 11:32:03 +02002546 memprintf(errmsg, "out of memory");
2547 goto error;
2548 }
2549 }
2550
2551 return chk;
2552
2553 error:
2554 free_tcpcheck_http_hdr(hdr);
2555 free_tcpcheck(chk, 0);
2556 return NULL;
2557}
2558
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002559int proxy_parse_httpchk_opt(char **args, int cur_arg, struct proxy *curpx, struct proxy *defpx,
2560 const char *file, int line)
2561{
Christopher Faulete5870d82020-04-15 11:32:03 +02002562 struct tcpcheck_ruleset *rs = NULL;
2563 struct tcpcheck_rules *rules = &curpx->tcpcheck_rules;
2564 struct tcpcheck_rule *chk;
2565 char *errmsg = NULL;
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002566 int err_code = 0;
2567
2568 if (warnifnotcap(curpx, PR_CAP_BE, file, line, args[cur_arg+1], NULL))
2569 err_code |= ERR_WARN;
2570
2571 if (alertif_too_many_args_idx(3, 1, file, line, args, &err_code))
2572 goto out;
2573
Christopher Faulete5870d82020-04-15 11:32:03 +02002574 chk = proxy_parse_httpchk_req(args, cur_arg+2, curpx, &errmsg);
2575 if (!chk) {
2576 ha_alert("parsing [%s:%d] : '%s %s' : %s.\n", file, line, args[0], args[1], errmsg);
2577 goto error;
2578 }
2579 if (errmsg) {
2580 ha_warning("parsing [%s:%d]: '%s %s' : %s\n", file, line, args[0], args[1], errmsg);
2581 err_code |= ERR_WARN;
2582 free(errmsg);
2583 errmsg = NULL;
2584 }
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002585
Christopher Faulete5870d82020-04-15 11:32:03 +02002586 no_request:
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002587 curpx->options2 &= ~PR_O2_CHK_ANY;
Christopher Faulete5870d82020-04-15 11:32:03 +02002588 curpx->options2 |= PR_O2_TCPCHK_CHK;
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002589
Christopher Faulete5870d82020-04-15 11:32:03 +02002590 free_tcpcheck_vars(&rules->preset_vars);
2591 rules->list = NULL;
2592 rules->flags |= TCPCHK_SND_HTTP_FROM_OPT;
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002593
Christopher Faulete5870d82020-04-15 11:32:03 +02002594 /* Deduce the ruleset name from the proxy info */
2595 chunk_printf(&trash, "*http-check-%s_%s-%d",
2596 ((curpx == defpx) ? "defaults" : curpx->id),
2597 curpx->conf.file, curpx->conf.line);
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002598
Christopher Faulet61cc8522020-04-20 14:54:42 +02002599 rs = find_tcpcheck_ruleset(b_orig(&trash));
Christopher Faulete5870d82020-04-15 11:32:03 +02002600 if (rs == NULL) {
Christopher Faulet61cc8522020-04-20 14:54:42 +02002601 rs = create_tcpcheck_ruleset(b_orig(&trash));
Christopher Faulete5870d82020-04-15 11:32:03 +02002602 if (rs == NULL) {
2603 ha_alert("parsing [%s:%d] : out of memory.\n", file, line);
2604 goto error;
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002605 }
Christopher Faulete5870d82020-04-15 11:32:03 +02002606 }
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002607
Christopher Faulete5870d82020-04-15 11:32:03 +02002608 rules->list = &rs->rules;
2609 rules->flags |= TCPCHK_RULES_HTTP_CHK;
2610 if (!tcpcheck_add_http_rule(chk, rules, &errmsg)) {
2611 ha_alert("parsing [%s:%d] : '%s %s' : %s.\n", file, line, args[0], args[1], errmsg);
2612 rules->list = NULL;
2613 goto error;
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002614 }
Christopher Faulete5870d82020-04-15 11:32:03 +02002615
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002616 out:
Christopher Faulete5870d82020-04-15 11:32:03 +02002617 free(errmsg);
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002618 return err_code;
2619
2620 error:
Christopher Faulet61cc8522020-04-20 14:54:42 +02002621 free_tcpcheck_ruleset(rs);
Christopher Faulete5870d82020-04-15 11:32:03 +02002622 free_tcpcheck(chk, 0);
Christopher Faulet6c2a7432020-04-09 14:48:48 +02002623 err_code |= ERR_ALERT | ERR_FATAL;
2624 goto out;
2625}
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002626
Christopher Fauletce8111e2020-04-06 15:04:11 +02002627/* Parse the "addr" server keyword */
2628static int srv_parse_addr(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2629 char **errmsg)
2630{
2631 struct sockaddr_storage *sk;
2632 struct protocol *proto;
2633 int port1, port2, err_code = 0;
2634
2635
2636 if (!*args[*cur_arg+1]) {
2637 memprintf(errmsg, "'%s' expects <ipv4|ipv6> as argument.", args[*cur_arg]);
2638 goto error;
2639 }
2640
2641 sk = str2sa_range(args[*cur_arg+1], NULL, &port1, &port2, errmsg, NULL, NULL, 1);
2642 if (!sk) {
2643 memprintf(errmsg, "'%s' : %s", args[*cur_arg], *errmsg);
2644 goto error;
2645 }
2646
2647 proto = protocol_by_family(sk->ss_family);
2648 if (!proto || !proto->connect) {
2649 memprintf(errmsg, "'%s %s' : connect() not supported for this address family.",
2650 args[*cur_arg], args[*cur_arg+1]);
2651 goto error;
2652 }
2653
2654 if (port1 != port2) {
2655 memprintf(errmsg, "'%s' : port ranges and offsets are not allowed in '%s'.",
2656 args[*cur_arg], args[*cur_arg+1]);
2657 goto error;
2658 }
2659
2660 srv->check.addr = srv->agent.addr = *sk;
2661 srv->flags |= SRV_F_CHECKADDR;
2662 srv->flags |= SRV_F_AGENTADDR;
2663
2664 out:
2665 return err_code;
2666
2667 error:
2668 err_code |= ERR_ALERT | ERR_FATAL;
2669 goto out;
2670}
2671
2672
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002673/* Parse the "agent-addr" server keyword */
2674static int srv_parse_agent_addr(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2675 char **errmsg)
2676{
2677 int err_code = 0;
2678
2679 if (!*(args[*cur_arg+1])) {
2680 memprintf(errmsg, "'%s' expects an address as argument.", args[*cur_arg]);
2681 goto error;
2682 }
2683 if(str2ip(args[*cur_arg+1], &srv->agent.addr) == NULL) {
2684 memprintf(errmsg, "parsing agent-addr failed. Check if '%s' is correct address.", args[*cur_arg+1]);
2685 goto error;
2686 }
2687
2688 out:
2689 return err_code;
2690
2691 error:
2692 err_code |= ERR_ALERT | ERR_FATAL;
2693 goto out;
2694}
2695
2696/* Parse the "agent-check" server keyword */
2697static int srv_parse_agent_check(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2698 char **errmsg)
2699{
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002700 struct tcpcheck_ruleset *rs = NULL;
2701 struct tcpcheck_rules *rules = srv->agent.tcpcheck_rules;
2702 struct tcpcheck_rule *chk;
2703 int err_code = 0;
2704
2705 if (srv->do_agent)
2706 goto out;
2707
2708 if (!rules) {
2709 rules = calloc(1, sizeof(*rules));
2710 if (!rules) {
2711 memprintf(errmsg, "out of memory.");
2712 goto error;
2713 }
2714 LIST_INIT(&rules->preset_vars);
2715 srv->agent.tcpcheck_rules = rules;
2716 }
2717 rules->list = NULL;
2718 rules->flags = 0;
2719
Christopher Faulet61cc8522020-04-20 14:54:42 +02002720 rs = find_tcpcheck_ruleset("*agent-check");
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002721 if (rs)
2722 goto ruleset_found;
2723
Christopher Faulet61cc8522020-04-20 14:54:42 +02002724 rs = create_tcpcheck_ruleset("*agent-check");
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002725 if (rs == NULL) {
2726 memprintf(errmsg, "out of memory.");
2727 goto error;
2728 }
2729
Christopher Fauletb50b3e62020-05-05 18:43:43 +02002730 chk = parse_tcpcheck_send((char *[]){"tcp-check", "send-lf", "%[var(check.agent_string)]", ""},
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002731 1, curpx, &rs->rules, srv->conf.file, srv->conf.line, errmsg);
2732 if (!chk) {
2733 memprintf(errmsg, "'%s': %s", args[*cur_arg], *errmsg);
2734 goto error;
2735 }
2736 chk->index = 0;
2737 LIST_ADDQ(&rs->rules, &chk->list);
2738
2739 chk = parse_tcpcheck_expect((char *[]){"tcp-check", "expect", "custom", ""},
Christopher Faulete5870d82020-04-15 11:32:03 +02002740 1, curpx, &rs->rules, TCPCHK_RULES_AGENT_CHK,
2741 srv->conf.file, srv->conf.line, errmsg);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002742 if (!chk) {
2743 memprintf(errmsg, "'%s': %s", args[*cur_arg], *errmsg);
2744 goto error;
2745 }
2746 chk->expect.custom = tcpcheck_agent_expect_reply;
2747 chk->index = 1;
2748 LIST_ADDQ(&rs->rules, &chk->list);
2749
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002750 ruleset_found:
2751 rules->list = &rs->rules;
Christopher Faulet404f9192020-04-09 23:13:54 +02002752 rules->flags |= TCPCHK_RULES_AGENT_CHK;
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002753 srv->do_agent = 1;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002754
2755 out:
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002756 return 0;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002757
2758 error:
2759 deinit_srv_agent_check(srv);
Christopher Faulet61cc8522020-04-20 14:54:42 +02002760 free_tcpcheck_ruleset(rs);
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002761 err_code |= ERR_ALERT | ERR_FATAL;
2762 goto out;
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002763}
2764
2765/* Parse the "agent-inter" server keyword */
2766static int srv_parse_agent_inter(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2767 char **errmsg)
2768{
2769 const char *err = NULL;
2770 unsigned int delay;
2771 int err_code = 0;
2772
2773 if (!*(args[*cur_arg+1])) {
2774 memprintf(errmsg, "'%s' expects a delay as argument.", args[*cur_arg]);
2775 goto error;
2776 }
2777
2778 err = parse_time_err(args[*cur_arg+1], &delay, TIME_UNIT_MS);
2779 if (err == PARSE_TIME_OVER) {
2780 memprintf(errmsg, "timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
2781 args[*cur_arg+1], args[*cur_arg], srv->id);
2782 goto error;
2783 }
2784 else if (err == PARSE_TIME_UNDER) {
2785 memprintf(errmsg, "timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
2786 args[*cur_arg+1], args[*cur_arg], srv->id);
2787 goto error;
2788 }
2789 else if (err) {
2790 memprintf(errmsg, "unexpected character '%c' in 'agent-inter' argument of server %s.",
2791 *err, srv->id);
2792 goto error;
2793 }
2794 if (delay <= 0) {
2795 memprintf(errmsg, "invalid value %d for argument '%s' of server %s.",
2796 delay, args[*cur_arg], srv->id);
2797 goto error;
2798 }
2799 srv->agent.inter = delay;
2800
2801 out:
2802 return err_code;
2803
2804 error:
2805 err_code |= ERR_ALERT | ERR_FATAL;
2806 goto out;
2807}
2808
2809/* Parse the "agent-port" server keyword */
2810static int srv_parse_agent_port(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2811 char **errmsg)
2812{
2813 int err_code = 0;
2814
2815 if (!*(args[*cur_arg+1])) {
2816 memprintf(errmsg, "'%s' expects a port number as argument.", args[*cur_arg]);
2817 goto error;
2818 }
2819
2820 global.maxsock++;
2821 srv->agent.port = atol(args[*cur_arg+1]);
2822
2823 out:
2824 return err_code;
2825
2826 error:
2827 err_code |= ERR_ALERT | ERR_FATAL;
2828 goto out;
2829}
2830
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002831int set_srv_agent_send(struct server *srv, const char *send)
2832{
2833 struct tcpcheck_rules *rules = srv->agent.tcpcheck_rules;
2834 struct tcpcheck_var *var = NULL;
2835 char *str;
2836
2837 str = strdup(send);
Christopher Fauletb61caf42020-04-21 10:57:42 +02002838 var = create_tcpcheck_var(ist("check.agent_string"));
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002839 if (str == NULL || var == NULL)
2840 goto error;
2841
2842 free_tcpcheck_vars(&rules->preset_vars);
2843
2844 var->data.type = SMP_T_STR;
2845 var->data.u.str.area = str;
2846 var->data.u.str.data = strlen(str);
2847 LIST_INIT(&var->list);
2848 LIST_ADDQ(&rules->preset_vars, &var->list);
2849
2850 return 1;
2851
2852 error:
2853 free(str);
2854 free(var);
2855 return 0;
2856}
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002857
2858/* Parse the "agent-send" server keyword */
2859static int srv_parse_agent_send(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2860 char **errmsg)
2861{
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002862 struct tcpcheck_rules *rules = srv->agent.tcpcheck_rules;
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002863 int err_code = 0;
2864
2865 if (!*(args[*cur_arg+1])) {
2866 memprintf(errmsg, "'%s' expects a string as argument.", args[*cur_arg]);
2867 goto error;
2868 }
2869
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002870 if (!rules) {
2871 rules = calloc(1, sizeof(*rules));
2872 if (!rules) {
2873 memprintf(errmsg, "out of memory.");
2874 goto error;
2875 }
2876 LIST_INIT(&rules->preset_vars);
2877 srv->agent.tcpcheck_rules = rules;
2878 }
2879
2880 if (!set_srv_agent_send(srv, args[*cur_arg+1])) {
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002881 memprintf(errmsg, "out of memory.");
2882 goto error;
2883 }
2884
2885 out:
2886 return err_code;
2887
2888 error:
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002889 deinit_srv_agent_check(srv);
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002890 err_code |= ERR_ALERT | ERR_FATAL;
2891 goto out;
2892}
2893
2894/* Parse the "no-agent-send" server keyword */
2895static int srv_parse_no_agent_check(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2896 char **errmsg)
2897{
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02002898 deinit_srv_agent_check(srv);
Christopher Fauletcbba66c2020-04-06 14:26:30 +02002899 return 0;
2900}
2901
Christopher Fauletce8111e2020-04-06 15:04:11 +02002902/* Parse the "check" server keyword */
2903static int srv_parse_check(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2904 char **errmsg)
2905{
2906 srv->do_check = 1;
2907 return 0;
2908}
2909
2910/* Parse the "check-send-proxy" server keyword */
2911static int srv_parse_check_send_proxy(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2912 char **errmsg)
2913{
2914 srv->check.send_proxy = 1;
2915 return 0;
2916}
2917
2918/* Parse the "check-via-socks4" server keyword */
2919static int srv_parse_check_via_socks4(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2920 char **errmsg)
2921{
2922 srv->check.via_socks4 = 1;
2923 return 0;
2924}
2925
2926/* Parse the "no-check" server keyword */
2927static int srv_parse_no_check(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2928 char **errmsg)
2929{
2930 deinit_srv_check(srv);
2931 return 0;
2932}
2933
2934/* Parse the "no-check-send-proxy" server keyword */
2935static int srv_parse_no_check_send_proxy(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2936 char **errmsg)
2937{
2938 srv->check.send_proxy = 0;
2939 return 0;
2940}
2941
Christopher Fauletedc6ed92020-04-23 16:27:59 +02002942/* parse the "check-proto" server keyword */
2943static int srv_parse_check_proto(char **args, int *cur_arg,
2944 struct proxy *px, struct server *newsrv, char **err)
2945{
2946 int err_code = 0;
2947
2948 if (!*args[*cur_arg + 1]) {
2949 memprintf(err, "'%s' : missing value", args[*cur_arg]);
2950 goto error;
2951 }
2952 newsrv->check.mux_proto = get_mux_proto(ist2(args[*cur_arg + 1], strlen(args[*cur_arg + 1])));
2953 if (!newsrv->check.mux_proto) {
2954 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
2955 goto error;
2956 }
2957
2958 out:
2959 return err_code;
2960
2961 error:
2962 err_code |= ERR_ALERT | ERR_FATAL;
2963 goto out;
2964}
2965
2966
Christopher Fauletce8111e2020-04-06 15:04:11 +02002967/* Parse the "rise" server keyword */
2968static int srv_parse_check_rise(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2969 char **errmsg)
2970{
2971 int err_code = 0;
2972
2973 if (!*args[*cur_arg + 1]) {
2974 memprintf(errmsg, "'%s' expects an integer argument.", args[*cur_arg]);
2975 goto error;
2976 }
2977
2978 srv->check.rise = atol(args[*cur_arg+1]);
2979 if (srv->check.rise <= 0) {
2980 memprintf(errmsg, "'%s' has to be > 0.", args[*cur_arg]);
2981 goto error;
2982 }
2983
2984 if (srv->check.health)
2985 srv->check.health = srv->check.rise;
2986
2987 out:
2988 return err_code;
2989
2990 error:
2991 deinit_srv_agent_check(srv);
2992 err_code |= ERR_ALERT | ERR_FATAL;
2993 goto out;
2994 return 0;
2995}
2996
2997/* Parse the "fall" server keyword */
2998static int srv_parse_check_fall(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
2999 char **errmsg)
3000{
3001 int err_code = 0;
3002
3003 if (!*args[*cur_arg + 1]) {
3004 memprintf(errmsg, "'%s' expects an integer argument.", args[*cur_arg]);
3005 goto error;
3006 }
3007
3008 srv->check.fall = atol(args[*cur_arg+1]);
3009 if (srv->check.fall <= 0) {
3010 memprintf(errmsg, "'%s' has to be > 0.", args[*cur_arg]);
3011 goto error;
3012 }
3013
3014 out:
3015 return err_code;
3016
3017 error:
3018 deinit_srv_agent_check(srv);
3019 err_code |= ERR_ALERT | ERR_FATAL;
3020 goto out;
3021 return 0;
3022}
3023
3024/* Parse the "inter" server keyword */
3025static int srv_parse_check_inter(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
3026 char **errmsg)
3027{
3028 const char *err = NULL;
3029 unsigned int delay;
3030 int err_code = 0;
3031
3032 if (!*(args[*cur_arg+1])) {
3033 memprintf(errmsg, "'%s' expects a delay as argument.", args[*cur_arg]);
3034 goto error;
3035 }
3036
3037 err = parse_time_err(args[*cur_arg+1], &delay, TIME_UNIT_MS);
3038 if (err == PARSE_TIME_OVER) {
3039 memprintf(errmsg, "timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
3040 args[*cur_arg+1], args[*cur_arg], srv->id);
3041 goto error;
3042 }
3043 else if (err == PARSE_TIME_UNDER) {
3044 memprintf(errmsg, "timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
3045 args[*cur_arg+1], args[*cur_arg], srv->id);
3046 goto error;
3047 }
3048 else if (err) {
3049 memprintf(errmsg, "unexpected character '%c' in 'agent-inter' argument of server %s.",
3050 *err, srv->id);
3051 goto error;
3052 }
3053 if (delay <= 0) {
3054 memprintf(errmsg, "invalid value %d for argument '%s' of server %s.",
3055 delay, args[*cur_arg], srv->id);
3056 goto error;
3057 }
3058 srv->check.inter = delay;
3059
3060 out:
3061 return err_code;
3062
3063 error:
3064 err_code |= ERR_ALERT | ERR_FATAL;
3065 goto out;
3066}
3067
3068
3069/* Parse the "fastinter" server keyword */
3070static int srv_parse_check_fastinter(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
3071 char **errmsg)
3072{
3073 const char *err = NULL;
3074 unsigned int delay;
3075 int err_code = 0;
3076
3077 if (!*(args[*cur_arg+1])) {
3078 memprintf(errmsg, "'%s' expects a delay as argument.", args[*cur_arg]);
3079 goto error;
3080 }
3081
3082 err = parse_time_err(args[*cur_arg+1], &delay, TIME_UNIT_MS);
3083 if (err == PARSE_TIME_OVER) {
3084 memprintf(errmsg, "timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
3085 args[*cur_arg+1], args[*cur_arg], srv->id);
3086 goto error;
3087 }
3088 else if (err == PARSE_TIME_UNDER) {
3089 memprintf(errmsg, "timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
3090 args[*cur_arg+1], args[*cur_arg], srv->id);
3091 goto error;
3092 }
3093 else if (err) {
3094 memprintf(errmsg, "unexpected character '%c' in 'agent-inter' argument of server %s.",
3095 *err, srv->id);
3096 goto error;
3097 }
3098 if (delay <= 0) {
3099 memprintf(errmsg, "invalid value %d for argument '%s' of server %s.",
3100 delay, args[*cur_arg], srv->id);
3101 goto error;
3102 }
3103 srv->check.fastinter = delay;
3104
3105 out:
3106 return err_code;
3107
3108 error:
3109 err_code |= ERR_ALERT | ERR_FATAL;
3110 goto out;
3111}
3112
3113
3114/* Parse the "downinter" server keyword */
3115static int srv_parse_check_downinter(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
3116 char **errmsg)
3117{
3118 const char *err = NULL;
3119 unsigned int delay;
3120 int err_code = 0;
3121
3122 if (!*(args[*cur_arg+1])) {
3123 memprintf(errmsg, "'%s' expects a delay as argument.", args[*cur_arg]);
3124 goto error;
3125 }
3126
3127 err = parse_time_err(args[*cur_arg+1], &delay, TIME_UNIT_MS);
3128 if (err == PARSE_TIME_OVER) {
3129 memprintf(errmsg, "timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).",
3130 args[*cur_arg+1], args[*cur_arg], srv->id);
3131 goto error;
3132 }
3133 else if (err == PARSE_TIME_UNDER) {
3134 memprintf(errmsg, "timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.",
3135 args[*cur_arg+1], args[*cur_arg], srv->id);
3136 goto error;
3137 }
3138 else if (err) {
3139 memprintf(errmsg, "unexpected character '%c' in 'agent-inter' argument of server %s.",
3140 *err, srv->id);
3141 goto error;
3142 }
3143 if (delay <= 0) {
3144 memprintf(errmsg, "invalid value %d for argument '%s' of server %s.",
3145 delay, args[*cur_arg], srv->id);
3146 goto error;
3147 }
3148 srv->check.downinter = delay;
3149
3150 out:
3151 return err_code;
3152
3153 error:
3154 err_code |= ERR_ALERT | ERR_FATAL;
3155 goto out;
3156}
3157
3158/* Parse the "port" server keyword */
3159static int srv_parse_check_port(char **args, int *cur_arg, struct proxy *curpx, struct server *srv,
3160 char **errmsg)
3161{
3162 int err_code = 0;
3163
3164 if (!*(args[*cur_arg+1])) {
3165 memprintf(errmsg, "'%s' expects a port number as argument.", args[*cur_arg]);
3166 goto error;
3167 }
3168
3169 global.maxsock++;
3170 srv->check.port = atol(args[*cur_arg+1]);
3171 srv->flags |= SRV_F_CHECKPORT;
3172
3173 out:
3174 return err_code;
3175
3176 error:
3177 err_code |= ERR_ALERT | ERR_FATAL;
3178 goto out;
3179}
3180
Christopher Fauletfd6c2292020-03-25 18:20:15 +01003181static struct cfg_kw_list cfg_kws = {ILH, {
Christopher Faulete9111b62020-04-09 18:12:08 +02003182 { CFG_LISTEN, "http-check", proxy_parse_httpcheck },
Christopher Fauletfd6c2292020-03-25 18:20:15 +01003183 { 0, NULL, NULL },
3184}};
3185
Christopher Fauletcbba66c2020-04-06 14:26:30 +02003186static struct srv_kw_list srv_kws = { "CHK", { }, {
Christopher Fauletce8111e2020-04-06 15:04:11 +02003187 { "addr", srv_parse_addr, 1, 1 }, /* IP address to send health to or to probe from agent-check */
Christopher Fauletcbba66c2020-04-06 14:26:30 +02003188 { "agent-addr", srv_parse_agent_addr, 1, 1 }, /* Enable an auxiliary agent check */
3189 { "agent-check", srv_parse_agent_check, 0, 1 }, /* Enable agent checks */
3190 { "agent-inter", srv_parse_agent_inter, 1, 1 }, /* Set the interval between two agent checks */
3191 { "agent-port", srv_parse_agent_port, 1, 1 }, /* Set the TCP port used for agent checks. */
3192 { "agent-send", srv_parse_agent_send, 1, 1 }, /* Set string to send to agent. */
Christopher Fauletce8111e2020-04-06 15:04:11 +02003193 { "check", srv_parse_check, 0, 1 }, /* Enable health checks */
Christopher Fauletedc6ed92020-04-23 16:27:59 +02003194 { "check-proto", srv_parse_check_proto, 1, 1 }, /* Set the mux protocol for health checks */
Christopher Fauletce8111e2020-04-06 15:04:11 +02003195 { "check-send-proxy", srv_parse_check_send_proxy, 0, 1 }, /* Enable PROXY protocol for health checks */
3196 { "check-via-socks4", srv_parse_check_via_socks4, 0, 1 }, /* Enable socks4 proxy for health checks */
Christopher Fauletcbba66c2020-04-06 14:26:30 +02003197 { "no-agent-check", srv_parse_no_agent_check, 0, 1 }, /* Do not enable any auxiliary agent check */
Christopher Fauletce8111e2020-04-06 15:04:11 +02003198 { "no-check", srv_parse_no_check, 0, 1 }, /* Disable health checks */
3199 { "no-check-send-proxy", srv_parse_no_check_send_proxy, 0, 1 }, /* Disable PROXY protol for health checks */
3200 { "rise", srv_parse_check_rise, 1, 1 }, /* Set rise value for health checks */
3201 { "fall", srv_parse_check_fall, 1, 1 }, /* Set fall value for health checks */
3202 { "inter", srv_parse_check_inter, 1, 1 }, /* Set inter value for health checks */
3203 { "fastinter", srv_parse_check_fastinter, 1, 1 }, /* Set fastinter value for health checks */
3204 { "downinter", srv_parse_check_downinter, 1, 1 }, /* Set downinter value for health checks */
3205 { "port", srv_parse_check_port, 1, 1 }, /* Set the TCP port used for health checks. */
Christopher Fauletcbba66c2020-04-06 14:26:30 +02003206 { NULL, NULL, 0 },
3207}};
3208
Christopher Fauletfd6c2292020-03-25 18:20:15 +01003209INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
Christopher Fauletcbba66c2020-04-06 14:26:30 +02003210INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Christopher Fauletfd6c2292020-03-25 18:20:15 +01003211
Willy Tarreaubd741542010-03-16 18:46:54 +01003212/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02003213 * Local variables:
3214 * c-indent-level: 8
3215 * c-basic-offset: 8
3216 * End:
3217 */