blob: 0badee3f8c61d7c36a7f255169a9ba1e031f6742 [file] [log] [blame]
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001/*
2 * Stream processing offload engine management.
3 *
4 * Copyright 2016 HAProxy Technologies, Christopher Faulet <cfaulet@haproxy.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12#include <ctype.h>
13#include <errno.h>
14
Willy Tarreaudcc048a2020-06-04 19:11:43 +020015#include <haproxy/acl.h>
Willy Tarreau122eba92020-06-04 10:15:32 +020016#include <haproxy/action-t.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020017#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020018#include <haproxy/arg.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020019#include <haproxy/cfgparse.h>
Tim Duesterhus75e2f8d2021-09-16 17:38:26 +020020#include <haproxy/check.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020021#include <haproxy/filters.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020022#include <haproxy/freq_ctr.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020023#include <haproxy/frontend.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020024#include <haproxy/global.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020025#include <haproxy/http_rules.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020026#include <haproxy/log.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020027#include <haproxy/pool.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020028#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020029#include <haproxy/sample.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020030#include <haproxy/session.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020031#include <haproxy/signal.h>
Christopher Faulet1d7d0f82021-02-19 10:56:41 +010032#include <haproxy/sink.h>
Willy Tarreau6c58ab02020-06-04 22:35:49 +020033#include <haproxy/spoe.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020034#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020035#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020036#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020037#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020038#include <haproxy/thread.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020039#include <haproxy/time.h>
Willy Tarreaue16ada12021-05-08 12:57:17 +020040#include <haproxy/tools.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020041#include <haproxy/vars.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020042
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020043
44#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
45#define SPOE_PRINTF(x...) fprintf(x)
Christopher Fauletb077cdc2018-01-24 16:37:57 +010046#define SPOE_DEBUG_STMT(statement) statement
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020047#else
48#define SPOE_PRINTF(x...)
Christopher Fauletb077cdc2018-01-24 16:37:57 +010049#define SPOE_DEBUG_STMT(statement)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020050#endif
51
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +010052/* Reserved 4 bytes to the frame size. So a frame and its size can be written
53 * together in a buffer */
54#define MAX_FRAME_SIZE global.tune.bufsize - 4
55
56/* The minimum size for a frame */
57#define MIN_FRAME_SIZE 256
58
Christopher Fauletf51f5fa2017-01-19 10:01:12 +010059/* Reserved for the metadata and the frame type.
60 * So <MAX_FRAME_SIZE> - <FRAME_HDR_SIZE> is the maximum payload size */
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +010061#define FRAME_HDR_SIZE 32
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020062
Christopher Fauletf51f5fa2017-01-19 10:01:12 +010063/* Helper to get SPOE ctx inside an appctx */
Christopher Faulet42bfa462017-01-04 14:14:19 +010064#define SPOE_APPCTX(appctx) ((struct spoe_appctx *)((appctx)->ctx.spoe.ptr))
65
Christopher Faulet3b386a32017-02-23 10:17:15 +010066/* SPOE filter id. Used to identify SPOE filters */
67const char *spoe_filter_id = "SPOE filter";
68
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020069/* Set if the handle on SIGUSR1 is registered */
70static int sighandler_registered = 0;
71
72/* proxy used during the parsing */
73struct proxy *curproxy = NULL;
74
75/* The name of the SPOE engine, used during the parsing */
76char *curengine = NULL;
77
78/* SPOE agent used during the parsing */
Christopher Faulet11610f32017-09-21 10:23:10 +020079/* SPOE agent/group/message used during the parsing */
80struct spoe_agent *curagent = NULL;
81struct spoe_group *curgrp = NULL;
82struct spoe_message *curmsg = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020083
84/* list of SPOE messages and placeholders used during the parsing */
85struct list curmsgs;
Christopher Faulet11610f32017-09-21 10:23:10 +020086struct list curgrps;
87struct list curmphs;
88struct list curgphs;
Christopher Faulet336d3ef2017-12-22 10:00:55 +010089struct list curvars;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020090
Christopher Faulet7250b8f2018-03-26 17:19:01 +020091/* list of log servers used during the parsing */
92struct list curlogsrvs;
93
Christopher Faulet0e0f0852018-03-26 17:20:36 +020094/* agent's proxy flags (PR_O_* and PR_O2_*) used during parsing */
95int curpxopts;
96int curpxopts2;
97
Christopher Faulet42bfa462017-01-04 14:14:19 +010098/* Pools used to allocate SPOE structs */
Willy Tarreau8ceae722018-11-26 11:58:30 +010099DECLARE_STATIC_POOL(pool_head_spoe_ctx, "spoe_ctx", sizeof(struct spoe_context));
100DECLARE_STATIC_POOL(pool_head_spoe_appctx, "spoe_appctx", sizeof(struct spoe_appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200101
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200102struct flt_ops spoe_ops;
103
Christopher Faulet8ef75252017-02-20 22:56:03 +0100104static int spoe_queue_context(struct spoe_context *ctx);
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200105static int spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait);
106static void spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait);
Christopher Faulet6f1296b2021-08-02 17:53:56 +0200107static struct appctx *spoe_create_appctx(struct spoe_config *conf);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200108
109/********************************************************************
110 * helper functions/globals
111 ********************************************************************/
112static void
Christopher Faulet11610f32017-09-21 10:23:10 +0200113spoe_release_placeholder(struct spoe_placeholder *ph)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200114{
Christopher Faulet11610f32017-09-21 10:23:10 +0200115 if (!ph)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200116 return;
Christopher Faulet11610f32017-09-21 10:23:10 +0200117 free(ph->id);
118 free(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200119}
120
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200121static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100122spoe_release_message(struct spoe_message *msg)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200123{
Christopher Faulet57583e42017-09-04 15:41:09 +0200124 struct spoe_arg *arg, *argback;
125 struct acl *acl, *aclback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200126
127 if (!msg)
128 return;
129 free(msg->id);
130 free(msg->conf.file);
Christopher Faulet57583e42017-09-04 15:41:09 +0200131 list_for_each_entry_safe(arg, argback, &msg->args, list) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200132 release_sample_expr(arg->expr);
133 free(arg->name);
Willy Tarreau2b718102021-04-21 07:32:39 +0200134 LIST_DELETE(&arg->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200135 free(arg);
136 }
Christopher Faulet57583e42017-09-04 15:41:09 +0200137 list_for_each_entry_safe(acl, aclback, &msg->acls, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200138 LIST_DELETE(&acl->list);
Christopher Faulet57583e42017-09-04 15:41:09 +0200139 prune_acl(acl);
140 free(acl);
141 }
142 if (msg->cond) {
143 prune_acl_cond(msg->cond);
144 free(msg->cond);
145 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200146 free(msg);
147}
148
149static void
Christopher Faulet11610f32017-09-21 10:23:10 +0200150spoe_release_group(struct spoe_group *grp)
151{
152 if (!grp)
153 return;
154 free(grp->id);
155 free(grp->conf.file);
156 free(grp);
157}
158
159static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100160spoe_release_agent(struct spoe_agent *agent)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200161{
Christopher Faulet11610f32017-09-21 10:23:10 +0200162 struct spoe_message *msg, *msgback;
163 struct spoe_group *grp, *grpback;
Christopher Faulet24289f22017-09-25 14:48:02 +0200164 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200165
166 if (!agent)
167 return;
168 free(agent->id);
169 free(agent->conf.file);
170 free(agent->var_pfx);
Christopher Faulet985532d2016-11-16 15:36:19 +0100171 free(agent->var_on_error);
Christopher Faulet36bda1c2018-03-22 09:08:20 +0100172 free(agent->var_t_process);
173 free(agent->var_t_total);
Christopher Faulet11610f32017-09-21 10:23:10 +0200174 list_for_each_entry_safe(msg, msgback, &agent->messages, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200175 LIST_DELETE(&msg->list);
Christopher Faulet11610f32017-09-21 10:23:10 +0200176 spoe_release_message(msg);
177 }
178 list_for_each_entry_safe(grp, grpback, &agent->groups, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200179 LIST_DELETE(&grp->list);
Christopher Faulet11610f32017-09-21 10:23:10 +0200180 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200181 }
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100182 if (agent->rt) {
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200183 for (i = 0; i < global.nbthread; ++i) {
184 free(agent->rt[i].engine_id);
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100185 HA_SPIN_DESTROY(&agent->rt[i].lock);
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200186 }
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100187 }
Christopher Faulet24289f22017-09-25 14:48:02 +0200188 free(agent->rt);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200189 free(agent);
190}
191
192static const char *spoe_frm_err_reasons[SPOE_FRM_ERRS] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100193 [SPOE_FRM_ERR_NONE] = "normal",
194 [SPOE_FRM_ERR_IO] = "I/O error",
195 [SPOE_FRM_ERR_TOUT] = "a timeout occurred",
196 [SPOE_FRM_ERR_TOO_BIG] = "frame is too big",
197 [SPOE_FRM_ERR_INVALID] = "invalid frame received",
198 [SPOE_FRM_ERR_NO_VSN] = "version value not found",
199 [SPOE_FRM_ERR_NO_FRAME_SIZE] = "max-frame-size value not found",
200 [SPOE_FRM_ERR_NO_CAP] = "capabilities value not found",
201 [SPOE_FRM_ERR_BAD_VSN] = "unsupported version",
202 [SPOE_FRM_ERR_BAD_FRAME_SIZE] = "max-frame-size too big or too small",
203 [SPOE_FRM_ERR_FRAG_NOT_SUPPORTED] = "fragmentation not supported",
204 [SPOE_FRM_ERR_INTERLACED_FRAMES] = "invalid interlaced frames",
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100205 [SPOE_FRM_ERR_FRAMEID_NOTFOUND] = "frame-id not found",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100206 [SPOE_FRM_ERR_RES] = "resource allocation error",
207 [SPOE_FRM_ERR_UNKNOWN] = "an unknown error occurred",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200208};
209
210static const char *spoe_event_str[SPOE_EV_EVENTS] = {
211 [SPOE_EV_ON_CLIENT_SESS] = "on-client-session",
212 [SPOE_EV_ON_TCP_REQ_FE] = "on-frontend-tcp-request",
213 [SPOE_EV_ON_TCP_REQ_BE] = "on-backend-tcp-request",
214 [SPOE_EV_ON_HTTP_REQ_FE] = "on-frontend-http-request",
215 [SPOE_EV_ON_HTTP_REQ_BE] = "on-backend-http-request",
216
217 [SPOE_EV_ON_SERVER_SESS] = "on-server-session",
218 [SPOE_EV_ON_TCP_RSP] = "on-tcp-response",
219 [SPOE_EV_ON_HTTP_RSP] = "on-http-response",
220};
221
222
223#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
224
225static const char *spoe_ctx_state_str[SPOE_CTX_ST_ERROR+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100226 [SPOE_CTX_ST_NONE] = "NONE",
227 [SPOE_CTX_ST_READY] = "READY",
228 [SPOE_CTX_ST_ENCODING_MSGS] = "ENCODING_MSGS",
229 [SPOE_CTX_ST_SENDING_MSGS] = "SENDING_MSGS",
230 [SPOE_CTX_ST_WAITING_ACK] = "WAITING_ACK",
231 [SPOE_CTX_ST_DONE] = "DONE",
232 [SPOE_CTX_ST_ERROR] = "ERROR",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200233};
234
235static const char *spoe_appctx_state_str[SPOE_APPCTX_ST_END+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100236 [SPOE_APPCTX_ST_CONNECT] = "CONNECT",
237 [SPOE_APPCTX_ST_CONNECTING] = "CONNECTING",
238 [SPOE_APPCTX_ST_IDLE] = "IDLE",
239 [SPOE_APPCTX_ST_PROCESSING] = "PROCESSING",
240 [SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY] = "SENDING_FRAG_NOTIFY",
241 [SPOE_APPCTX_ST_WAITING_SYNC_ACK] = "WAITING_SYNC_ACK",
242 [SPOE_APPCTX_ST_DISCONNECT] = "DISCONNECT",
243 [SPOE_APPCTX_ST_DISCONNECTING] = "DISCONNECTING",
244 [SPOE_APPCTX_ST_EXIT] = "EXIT",
245 [SPOE_APPCTX_ST_END] = "END",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200246};
247
248#endif
Christopher Fauleta1cda022016-12-21 08:58:06 +0100249
Christopher Faulet8ef75252017-02-20 22:56:03 +0100250/* Used to generates a unique id for an engine. On success, it returns a
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500251 * allocated string. So it is the caller's responsibility to release it. If the
Christopher Faulet8ef75252017-02-20 22:56:03 +0100252 * allocation failed, it returns NULL. */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100253static char *
254generate_pseudo_uuid()
255{
Willy Tarreauee3bcdd2020-03-08 17:48:17 +0100256 ha_generate_uuid(&trash);
Kevin Zhu079f8082020-03-13 10:39:51 +0800257 return my_strndup(trash.area, trash.data);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100258}
259
Christopher Fauletb2dd1e02018-03-22 09:07:41 +0100260
261static inline void
262spoe_update_stat_time(struct timeval *tv, long *t)
263{
264 if (*t == -1)
265 *t = tv_ms_elapsed(tv, &now);
266 else
267 *t += tv_ms_elapsed(tv, &now);
268 tv_zero(tv);
269}
270
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200271/********************************************************************
272 * Functions that encode/decode SPOE frames
273 ********************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200274/* Helper to get static string length, excluding the terminating null byte */
275#define SLEN(str) (sizeof(str)-1)
276
277/* Predefined key used in HELLO/DISCONNECT frames */
278#define SUPPORTED_VERSIONS_KEY "supported-versions"
279#define VERSION_KEY "version"
280#define MAX_FRAME_SIZE_KEY "max-frame-size"
281#define CAPABILITIES_KEY "capabilities"
Christopher Fauleta1cda022016-12-21 08:58:06 +0100282#define ENGINE_ID_KEY "engine-id"
Christopher Fauletba7bc162016-11-07 21:07:38 +0100283#define HEALTHCHECK_KEY "healthcheck"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200284#define STATUS_CODE_KEY "status-code"
285#define MSG_KEY "message"
286
287struct spoe_version {
288 char *str;
289 int min;
290 int max;
291};
292
293/* All supported versions */
294static struct spoe_version supported_versions[] = {
Christopher Faulet63816502018-05-31 14:56:42 +0200295 /* 1.0 is now unsupported because of a bug about frame's flags*/
296 {"2.0", 2000, 2000},
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200297 {NULL, 0, 0}
298};
299
300/* Comma-separated list of supported versions */
Christopher Faulet63816502018-05-31 14:56:42 +0200301#define SUPPORTED_VERSIONS_VAL "2.0"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200302
Christopher Faulet8ef75252017-02-20 22:56:03 +0100303/* Convert a string to a SPOE version value. The string must follow the format
304 * "MAJOR.MINOR". It will be concerted into the integer (1000 * MAJOR + MINOR).
305 * If an error occurred, -1 is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200306static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100307spoe_str_to_vsn(const char *str, size_t len)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200308{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100309 const char *p, *end;
310 int maj, min, vsn;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200311
Christopher Faulet8ef75252017-02-20 22:56:03 +0100312 p = str;
313 end = str+len;
314 maj = min = 0;
315 vsn = -1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200316
Christopher Faulet8ef75252017-02-20 22:56:03 +0100317 /* skip leading spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100318 while (p < end && isspace((unsigned char)*p))
Christopher Faulet8ef75252017-02-20 22:56:03 +0100319 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200320
Christopher Faulet8ef75252017-02-20 22:56:03 +0100321 /* parse Major number, until the '.' */
322 while (*p != '.') {
323 if (p >= end || *p < '0' || *p > '9')
324 goto out;
325 maj *= 10;
326 maj += (*p - '0');
327 p++;
328 }
329
330 /* check Major version */
331 if (!maj)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200332 goto out;
333
Christopher Faulet8ef75252017-02-20 22:56:03 +0100334 p++; /* skip the '.' */
335 if (p >= end || *p < '0' || *p > '9') /* Minor number is missing */
336 goto out;
337
338 /* Parse Minor number */
339 while (p < end) {
340 if (*p < '0' || *p > '9')
341 break;
342 min *= 10;
343 min += (*p - '0');
344 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200345 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100346
347 /* check Minor number */
348 if (min > 999)
349 goto out;
350
351 /* skip trailing spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100352 while (p < end && isspace((unsigned char)*p))
Christopher Faulet8ef75252017-02-20 22:56:03 +0100353 p++;
354 if (p != end)
355 goto out;
356
357 vsn = maj * 1000 + min;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200358 out:
359 return vsn;
360}
361
Christopher Faulet8ef75252017-02-20 22:56:03 +0100362/* Encode the HELLO frame sent by HAProxy to an agent. It returns the number of
Joseph Herlantf7f60312018-11-15 13:46:49 -0800363 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
Christopher Faulet8ef75252017-02-20 22:56:03 +0100364 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200365static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100366spoe_prepare_hahello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200367{
Willy Tarreau83061a82018-07-13 11:56:34 +0200368 struct buffer *chk;
Christopher Faulet42bfa462017-01-04 14:14:19 +0100369 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100370 char *p, *end;
371 unsigned int flags = SPOE_FRM_FL_FIN;
372 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200373
Christopher Faulet8ef75252017-02-20 22:56:03 +0100374 p = frame;
375 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200376
Christopher Faulet8ef75252017-02-20 22:56:03 +0100377 /* Set Frame type */
378 *p++ = SPOE_FRM_T_HAPROXY_HELLO;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200379
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100380 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200381 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100382 memcpy(p, (char *)&flags, 4);
383 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200384
385 /* No stream-id and frame-id for HELLO frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100386 *p++ = 0; *p++ = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200387
388 /* There are 3 mandatory items: "supported-versions", "max-frame-size"
389 * and "capabilities" */
390
391 /* "supported-versions" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100392 sz = SLEN(SUPPORTED_VERSIONS_KEY);
393 if (spoe_encode_buffer(SUPPORTED_VERSIONS_KEY, sz, &p, end) == -1)
394 goto too_big;
395
396 *p++ = SPOE_DATA_T_STR;
397 sz = SLEN(SUPPORTED_VERSIONS_VAL);
398 if (spoe_encode_buffer(SUPPORTED_VERSIONS_VAL, sz, &p, end) == -1)
399 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200400
401 /* "max-fram-size" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100402 sz = SLEN(MAX_FRAME_SIZE_KEY);
403 if (spoe_encode_buffer(MAX_FRAME_SIZE_KEY, sz, &p, end) == -1)
404 goto too_big;
405
406 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200407 if (encode_varint(SPOE_APPCTX(appctx)->max_frame_size, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100408 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200409
410 /* "capabilities" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100411 sz = SLEN(CAPABILITIES_KEY);
412 if (spoe_encode_buffer(CAPABILITIES_KEY, sz, &p, end) == -1)
413 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200414
Christopher Faulet8ef75252017-02-20 22:56:03 +0100415 *p++ = SPOE_DATA_T_STR;
Christopher Faulet305c6072017-02-23 16:17:53 +0100416 chk = get_trash_chunk();
417 if (agent != NULL && (agent->flags & SPOE_FL_PIPELINING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200418 memcpy(chk->area, "pipelining", 10);
419 chk->data += 10;
Christopher Faulet305c6072017-02-23 16:17:53 +0100420 }
421 if (agent != NULL && (agent->flags & SPOE_FL_ASYNC)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200422 if (chk->data) chk->area[chk->data++] = ',';
423 memcpy(chk->area+chk->data, "async", 5);
424 chk->data += 5;
Christopher Faulet305c6072017-02-23 16:17:53 +0100425 }
Christopher Fauletcecd8522017-02-24 22:11:21 +0100426 if (agent != NULL && (agent->flags & SPOE_FL_RCV_FRAGMENTATION)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200427 if (chk->data) chk->area[chk->data++] = ',';
428 memcpy(chk->area+chk->data, "fragmentation", 13);
Miroslav Zagorac6b3690b2019-01-13 16:55:01 +0100429 chk->data += 13;
Christopher Fauletcecd8522017-02-24 22:11:21 +0100430 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200431 if (spoe_encode_buffer(chk->area, chk->data, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100432 goto too_big;
433
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500434 /* (optional) "engine-id" K/V item, if present */
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200435 if (agent != NULL && agent->rt[tid].engine_id != NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100436 sz = SLEN(ENGINE_ID_KEY);
437 if (spoe_encode_buffer(ENGINE_ID_KEY, sz, &p, end) == -1)
438 goto too_big;
439
440 *p++ = SPOE_DATA_T_STR;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200441 sz = strlen(agent->rt[tid].engine_id);
442 if (spoe_encode_buffer(agent->rt[tid].engine_id, sz, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100443 goto too_big;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100444 }
445
Christopher Faulet8ef75252017-02-20 22:56:03 +0100446 return (p - frame);
447
448 too_big:
449 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
450 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200451}
452
Christopher Faulet8ef75252017-02-20 22:56:03 +0100453/* Encode DISCONNECT frame sent by HAProxy to an agent. It returns the number of
454 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
455 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200456static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100457spoe_prepare_hadiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200458{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100459 const char *reason;
460 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100461 unsigned int flags = SPOE_FRM_FL_FIN;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100462 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200463
Christopher Faulet8ef75252017-02-20 22:56:03 +0100464 p = frame;
465 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200466
Christopher Faulet8ef75252017-02-20 22:56:03 +0100467 /* Set Frame type */
468 *p++ = SPOE_FRM_T_HAPROXY_DISCON;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200469
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100470 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200471 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100472 memcpy(p, (char *)&flags, 4);
473 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200474
475 /* No stream-id and frame-id for DISCONNECT frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100476 *p++ = 0; *p++ = 0;
477
478 if (SPOE_APPCTX(appctx)->status_code >= SPOE_FRM_ERRS)
479 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200480
481 /* There are 2 mandatory items: "status-code" and "message" */
482
483 /* "status-code" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100484 sz = SLEN(STATUS_CODE_KEY);
485 if (spoe_encode_buffer(STATUS_CODE_KEY, sz, &p, end) == -1)
486 goto too_big;
487
488 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200489 if (encode_varint(SPOE_APPCTX(appctx)->status_code, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100490 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200491
492 /* "message" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100493 sz = SLEN(MSG_KEY);
494 if (spoe_encode_buffer(MSG_KEY, sz, &p, end) == -1)
495 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200496
Christopher Faulet8ef75252017-02-20 22:56:03 +0100497 /*Get the message corresponding to the status code */
498 reason = spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code];
499
500 *p++ = SPOE_DATA_T_STR;
501 sz = strlen(reason);
502 if (spoe_encode_buffer(reason, sz, &p, end) == -1)
503 goto too_big;
504
505 return (p - frame);
506
507 too_big:
508 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
509 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200510}
511
Christopher Faulet8ef75252017-02-20 22:56:03 +0100512/* Encode the NOTIFY frame sent by HAProxy to an agent. It returns the number of
513 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
514 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200515static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100516spoe_prepare_hanotify_frame(struct appctx *appctx, struct spoe_context *ctx,
Christopher Fauleta1cda022016-12-21 08:58:06 +0100517 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200518{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100519 char *p, *end;
520 unsigned int stream_id, frame_id;
521 unsigned int flags = SPOE_FRM_FL_FIN;
522 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200523
Christopher Faulet8ef75252017-02-20 22:56:03 +0100524 p = frame;
525 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200526
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100527 stream_id = ctx->stream_id;
528 frame_id = ctx->frame_id;
529
530 if (ctx->flags & SPOE_CTX_FL_FRAGMENTED) {
531 /* The fragmentation is not supported by the applet */
532 if (!(SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_FRAGMENTATION)) {
533 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
534 return -1;
535 }
536 flags = ctx->frag_ctx.flags;
537 }
538
539 /* Set Frame type */
540 *p++ = SPOE_FRM_T_HAPROXY_NOTIFY;
541
542 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200543 flags = htonl(flags);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100544 memcpy(p, (char *)&flags, 4);
545 p += 4;
546
547 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200548 if (encode_varint(stream_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100549 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200550 if (encode_varint(frame_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100551 goto too_big;
552
553 /* Copy encoded messages, if possible */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200554 sz = b_data(&ctx->buffer);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100555 if (p + sz >= end)
556 goto too_big;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200557 memcpy(p, b_head(&ctx->buffer), sz);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100558 p += sz;
559
560 return (p - frame);
561
562 too_big:
563 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
564 return 0;
565}
566
567/* Encode next part of a fragmented frame sent by HAProxy to an agent. It
568 * returns the number of encoded bytes in the frame on success, 0 if an encoding
569 * error occurred and -1 if a fatal error occurred. */
570static int
571spoe_prepare_hafrag_frame(struct appctx *appctx, struct spoe_context *ctx,
572 char *frame, size_t size)
573{
574 char *p, *end;
575 unsigned int stream_id, frame_id;
576 unsigned int flags;
577 size_t sz;
578
579 p = frame;
580 end = frame+size;
581
Christopher Faulet8ef75252017-02-20 22:56:03 +0100582 /* <ctx> is null when the stream has aborted the processing of a
583 * fragmented frame. In this case, we must notify the corresponding
584 * agent using ids stored in <frag_ctx>. */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100585 if (ctx == NULL) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100586 flags = (SPOE_FRM_FL_FIN|SPOE_FRM_FL_ABRT);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100587 stream_id = SPOE_APPCTX(appctx)->frag_ctx.cursid;
588 frame_id = SPOE_APPCTX(appctx)->frag_ctx.curfid;
589 }
590 else {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100591 flags = ctx->frag_ctx.flags;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100592 stream_id = ctx->stream_id;
593 frame_id = ctx->frame_id;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100594 }
595
Christopher Faulet8ef75252017-02-20 22:56:03 +0100596 /* Set Frame type */
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100597 *p++ = SPOE_FRM_T_UNSET;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100598
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100599 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200600 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100601 memcpy(p, (char *)&flags, 4);
602 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200603
604 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200605 if (encode_varint(stream_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100606 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200607 if (encode_varint(frame_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100608 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200609
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100610 if (ctx == NULL)
611 goto end;
612
Christopher Faulet8ef75252017-02-20 22:56:03 +0100613 /* Copy encoded messages, if possible */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200614 sz = b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100615 if (p + sz >= end)
616 goto too_big;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200617 memcpy(p, b_head(&ctx->buffer), sz);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100618 p += sz;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100619
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100620 end:
Christopher Faulet8ef75252017-02-20 22:56:03 +0100621 return (p - frame);
622
623 too_big:
624 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
625 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200626}
627
Christopher Faulet8ef75252017-02-20 22:56:03 +0100628/* Decode and process the HELLO frame sent by an agent. It returns the number of
629 * read bytes on success, 0 if a decoding error occurred, and -1 if a fatal
630 * error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200631static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100632spoe_handle_agenthello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200633{
Christopher Faulet305c6072017-02-23 16:17:53 +0100634 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
635 char *p, *end;
636 int vsn, max_frame_size;
637 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100638
639 p = frame;
640 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200641
642 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100643 if (*p++ != SPOE_FRM_T_AGENT_HELLO) {
644 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200645 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100646 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200647
Christopher Faulet8ef75252017-02-20 22:56:03 +0100648 if (size < 7 /* TYPE + METADATA */) {
649 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
650 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200651 }
652
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100653 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100654 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200655 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100656 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200657
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100658 /* Fragmentation is not supported for HELLO frame */
659 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100660 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100661 return -1;
662 }
663
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200664 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100665 if (*p != 0 || *(p+1) != 0) {
666 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
667 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200668 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100669 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200670
671 /* There are 3 mandatory items: "version", "max-frame-size" and
672 * "capabilities" */
673
674 /* Loop on K/V items */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100675 vsn = max_frame_size = flags = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100676 while (p < end) {
677 char *str;
Frédéric Lécaille6ca71a92017-08-22 10:33:14 +0200678 uint64_t sz;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100679 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200680
681 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100682 ret = spoe_decode_buffer(&p, end, &str, &sz);
683 if (ret == -1 || !sz) {
684 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
685 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200686 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100687
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200688 /* Check "version" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200689 if (sz >= strlen(VERSION_KEY) && !memcmp(str, VERSION_KEY, strlen(VERSION_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100690 int i, type = *p++;
691
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200692 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100693 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
694 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
695 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200696 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100697 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
698 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
699 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200700 }
701
Christopher Faulet8ef75252017-02-20 22:56:03 +0100702 vsn = spoe_str_to_vsn(str, sz);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200703 if (vsn == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100704 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200705 return -1;
706 }
707 for (i = 0; supported_versions[i].str != NULL; ++i) {
708 if (vsn >= supported_versions[i].min &&
709 vsn <= supported_versions[i].max)
710 break;
711 }
712 if (supported_versions[i].str == NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100713 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200714 return -1;
715 }
716 }
717 /* Check "max-frame-size" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200718 else if (sz >= strlen(MAX_FRAME_SIZE_KEY) && !memcmp(str, MAX_FRAME_SIZE_KEY, strlen(MAX_FRAME_SIZE_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100719 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200720
721 /* The value must be integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200722 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
723 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
724 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
725 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100726 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
727 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200728 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200729 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100730 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
731 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200732 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100733 if (sz < MIN_FRAME_SIZE ||
734 sz > SPOE_APPCTX(appctx)->max_frame_size) {
735 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200736 return -1;
737 }
738 max_frame_size = sz;
739 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100740 /* Check "capabilities" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200741 else if (sz >= strlen(CAPABILITIES_KEY) && !memcmp(str, CAPABILITIES_KEY, strlen(CAPABILITIES_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100742 int type = *p++;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100743
744 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100745 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
746 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
747 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100748 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100749 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
750 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
751 return 0;
752 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100753
Christopher Faulet8ef75252017-02-20 22:56:03 +0100754 while (sz) {
Christopher Fauleta1cda022016-12-21 08:58:06 +0100755 char *delim;
756
757 /* Skip leading spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100758 for (; isspace((unsigned char)*str) && sz; str++, sz--);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100759
Christopher Faulet8ef75252017-02-20 22:56:03 +0100760 if (sz >= 10 && !strncmp(str, "pipelining", 10)) {
761 str += 10; sz -= 10;
Willy Tarreau90807112020-02-25 08:16:33 +0100762 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100763 flags |= SPOE_APPCTX_FL_PIPELINING;
764 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100765 else if (sz >= 5 && !strncmp(str, "async", 5)) {
766 str += 5; sz -= 5;
Willy Tarreau90807112020-02-25 08:16:33 +0100767 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100768 flags |= SPOE_APPCTX_FL_ASYNC;
769 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100770 else if (sz >= 13 && !strncmp(str, "fragmentation", 13)) {
771 str += 13; sz -= 13;
Willy Tarreau90807112020-02-25 08:16:33 +0100772 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100773 flags |= SPOE_APPCTX_FL_FRAGMENTATION;
774 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100775
Christopher Faulet8ef75252017-02-20 22:56:03 +0100776 /* Get the next comma or break */
777 if (!sz || (delim = memchr(str, ',', sz)) == NULL)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100778 break;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100779 delim++;
780 sz -= (delim - str);
781 str = delim;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100782 }
783 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200784 else {
785 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100786 if (spoe_skip_data(&p, end) == -1) {
787 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
788 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200789 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200790 }
791 }
792
793 /* Final checks */
794 if (!vsn) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100795 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200796 return -1;
797 }
798 if (!max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100799 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200800 return -1;
801 }
Christopher Faulet11389012019-02-07 16:13:26 +0100802 if (!agent)
803 flags &= ~(SPOE_APPCTX_FL_PIPELINING|SPOE_APPCTX_FL_ASYNC);
804 else {
805 if ((flags & SPOE_APPCTX_FL_PIPELINING) && !(agent->flags & SPOE_FL_PIPELINING))
806 flags &= ~SPOE_APPCTX_FL_PIPELINING;
807 if ((flags & SPOE_APPCTX_FL_ASYNC) && !(agent->flags & SPOE_FL_ASYNC))
808 flags &= ~SPOE_APPCTX_FL_ASYNC;
809 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200810
Christopher Faulet42bfa462017-01-04 14:14:19 +0100811 SPOE_APPCTX(appctx)->version = (unsigned int)vsn;
812 SPOE_APPCTX(appctx)->max_frame_size = (unsigned int)max_frame_size;
813 SPOE_APPCTX(appctx)->flags |= flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100814
815 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200816}
817
818/* Decode DISCONNECT frame sent by an agent. It returns the number of by read
819 * bytes on success, 0 if the frame can be ignored and -1 if an error
820 * occurred. */
821static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100822spoe_handle_agentdiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200823{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100824 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100825 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100826
827 p = frame;
828 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200829
830 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100831 if (*p++ != SPOE_FRM_T_AGENT_DISCON) {
832 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200833 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100834 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200835
Christopher Faulet8ef75252017-02-20 22:56:03 +0100836 if (size < 7 /* TYPE + METADATA */) {
837 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
838 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200839 }
840
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100841 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100842 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200843 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100844 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200845
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100846 /* Fragmentation is not supported for DISCONNECT frame */
847 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100848 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100849 return -1;
850 }
851
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200852 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100853 if (*p != 0 || *(p+1) != 0) {
854 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
855 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200856 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100857 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200858
859 /* There are 2 mandatory items: "status-code" and "message" */
860
861 /* Loop on K/V items */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100862 while (p < end) {
863 char *str;
Frédéric Lécaille6ca71a92017-08-22 10:33:14 +0200864 uint64_t sz;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100865 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200866
867 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100868 ret = spoe_decode_buffer(&p, end, &str, &sz);
869 if (ret == -1 || !sz) {
870 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
871 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200872 }
873
874 /* Check "status-code" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200875 if (sz >= strlen(STATUS_CODE_KEY) && !memcmp(str, STATUS_CODE_KEY, strlen(STATUS_CODE_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100876 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200877
878 /* The value must be an integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200879 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
880 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
881 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
882 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100883 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
884 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200885 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200886 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100887 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
888 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200889 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100890 SPOE_APPCTX(appctx)->status_code = sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200891 }
892
893 /* Check "message" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200894 else if (sz >= strlen(MSG_KEY) && !memcmp(str, MSG_KEY, strlen(MSG_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100895 int type = *p++;
896
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200897 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100898 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
899 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
900 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200901 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100902 ret = spoe_decode_buffer(&p, end, &str, &sz);
903 if (ret == -1 || sz > 255) {
904 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
905 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200906 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100907#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
908 SPOE_APPCTX(appctx)->reason = str;
909 SPOE_APPCTX(appctx)->rlen = sz;
910#endif
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200911 }
912 else {
913 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100914 if (spoe_skip_data(&p, end) == -1) {
915 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
916 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200917 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200918 }
919 }
920
Christopher Faulet8ef75252017-02-20 22:56:03 +0100921 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200922}
923
924
Christopher Fauleta1cda022016-12-21 08:58:06 +0100925/* Decode ACK frame sent by an agent. It returns the number of read bytes on
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200926 * success, 0 if the frame can be ignored and -1 if an error occurred. */
927static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100928spoe_handle_agentack_frame(struct appctx *appctx, struct spoe_context **ctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100929 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200930{
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100931 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100932 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100933 uint64_t stream_id, frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100934 int len;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100935 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100936
937 p = frame;
938 end = frame + size;
939 *ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200940
941 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100942 if (*p++ != SPOE_FRM_T_AGENT_ACK) {
943 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200944 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100945 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200946
Christopher Faulet8ef75252017-02-20 22:56:03 +0100947 if (size < 7 /* TYPE + METADATA */) {
948 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
949 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200950 }
951
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100952 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100953 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200954 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100955 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200956
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100957 /* Fragmentation is not supported for now */
958 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100959 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100960 return -1;
961 }
962
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200963 /* Get the stream-id and the frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200964 if (decode_varint(&p, end, &stream_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100965 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100966 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100967 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200968 if (decode_varint(&p, end, &frame_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100969 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200970 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100971 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100972
Christopher Faulet8ef75252017-02-20 22:56:03 +0100973 /* Try to find the corresponding SPOE context */
Christopher Faulet42bfa462017-01-04 14:14:19 +0100974 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
Christopher Faulet24289f22017-09-25 14:48:02 +0200975 list_for_each_entry((*ctx), &agent->rt[tid].waiting_queue, list) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100976 if ((*ctx)->stream_id == (unsigned int)stream_id &&
977 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100978 goto found;
979 }
980 }
981 else {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100982 list_for_each_entry((*ctx), &SPOE_APPCTX(appctx)->waiting_queue, list) {
983 if ((*ctx)->stream_id == (unsigned int)stream_id &&
Christopher Faulet8ef75252017-02-20 22:56:03 +0100984 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100985 goto found;
986 }
987 }
988
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100989 if (SPOE_APPCTX(appctx)->frag_ctx.ctx &&
990 SPOE_APPCTX(appctx)->frag_ctx.cursid == (unsigned int)stream_id &&
991 SPOE_APPCTX(appctx)->frag_ctx.curfid == (unsigned int)frame_id) {
992
993 /* ABRT bit is set for an unfinished fragmented frame */
994 if (flags & SPOE_FRM_FL_ABRT) {
995 *ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100996 (*ctx)->state = SPOE_CTX_ST_ERROR;
997 (*ctx)->status_code = SPOE_CTX_ERR_FRAG_FRAME_ABRT;
998 /* Ignore the payload */
999 goto end;
1000 }
1001 /* TODO: Handle more flags for fragmented frames: RESUME, FINISH... */
1002 /* For now, we ignore the ack */
1003 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
1004 return 0;
1005 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001006
Christopher Fauleta1cda022016-12-21 08:58:06 +01001007 /* No Stream found, ignore the frame */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001008 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1009 " - Ignore ACK frame"
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001010 " - stream-id=%u - frame-id=%u\n",
1011 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1012 __FUNCTION__, appctx,
1013 (unsigned int)stream_id, (unsigned int)frame_id);
1014
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001015 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAMEID_NOTFOUND;
Christopher Fauletc7ba9102020-11-10 14:31:39 +01001016 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK) {
1017 /* Report an error if we are waiting the ack for another frame,
1018 * but not if there is no longer frame waiting for a ack
1019 * (timeout)
1020 */
1021 if (!LIST_ISEMPTY(&SPOE_APPCTX(appctx)->waiting_queue) ||
1022 SPOE_APPCTX(appctx)->frag_ctx.ctx)
1023 return -1;
1024 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1025 SPOE_APPCTX(appctx)->cur_fpa = 0;
1026 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001027 return 0;
1028
1029 found:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001030 if (!spoe_acquire_buffer(&SPOE_APPCTX(appctx)->buffer,
1031 &SPOE_APPCTX(appctx)->buffer_wait)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001032 *ctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001033 return 1; /* Retry later */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001034 }
Christopher Faulet4596fb72017-01-11 14:05:19 +01001035
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001036 /* Copy encoded actions */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001037 len = (end - p);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001038 memcpy(b_head(&SPOE_APPCTX(appctx)->buffer), p, len);
1039 b_set_data(&SPOE_APPCTX(appctx)->buffer, len);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001040 p += len;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001041
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001042 /* Transfer the buffer ownership to the SPOE context */
1043 (*ctx)->buffer = SPOE_APPCTX(appctx)->buffer;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001044 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001045
Christopher Faulet8ef75252017-02-20 22:56:03 +01001046 (*ctx)->state = SPOE_CTX_ST_DONE;
1047
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001048 end:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001049 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001050 " - ACK frame received"
1051 " - ctx=%p - stream-id=%u - frame-id=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001052 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001053 __FUNCTION__, appctx, *ctx, (*ctx)->stream_id,
1054 (*ctx)->frame_id, flags);
1055 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001056}
1057
Christopher Fauletba7bc162016-11-07 21:07:38 +01001058/* This function is used in cfgparse.c and declared in proto/checks.h. It
1059 * prepare the request to send to agents during a healthcheck. It returns 0 on
1060 * success and -1 if an error occurred. */
1061int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001062spoe_prepare_healthcheck_request(char **req, int *len)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001063{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001064 struct appctx appctx;
1065 struct spoe_appctx spoe_appctx;
1066 char *frame, *end, buf[MAX_FRAME_SIZE+4];
1067 size_t sz;
1068 int ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001069
Christopher Faulet42bfa462017-01-04 14:14:19 +01001070 memset(&appctx, 0, sizeof(appctx));
1071 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001072 memset(buf, 0, sizeof(buf));
Christopher Faulet42bfa462017-01-04 14:14:19 +01001073
1074 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001075 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001076
Christopher Faulet8ef75252017-02-20 22:56:03 +01001077 frame = buf+4; /* Reserved the 4 first bytes for the frame size */
1078 end = frame + MAX_FRAME_SIZE;
1079
1080 ret = spoe_prepare_hahello_frame(&appctx, frame, MAX_FRAME_SIZE);
1081 if (ret <= 0)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001082 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001083 frame += ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001084
Christopher Faulet8ef75252017-02-20 22:56:03 +01001085 /* Add "healthcheck" K/V item */
1086 sz = SLEN(HEALTHCHECK_KEY);
1087 if (spoe_encode_buffer(HEALTHCHECK_KEY, sz, &frame, end) == -1)
1088 return -1;
1089 *frame++ = (SPOE_DATA_T_BOOL | SPOE_DATA_FL_TRUE);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001090
Christopher Faulet8ef75252017-02-20 22:56:03 +01001091 *len = frame - buf;
1092 sz = htonl(*len - 4);
1093 memcpy(buf, (char *)&sz, 4);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001094
Christopher Faulet8ef75252017-02-20 22:56:03 +01001095 if ((*req = malloc(*len)) == NULL)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001096 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001097 memcpy(*req, buf, *len);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001098 return 0;
1099}
1100
1101/* This function is used in checks.c and declared in proto/checks.h. It decode
1102 * the response received from an agent during a healthcheck. It returns 0 on
1103 * success and -1 if an error occurred. */
1104int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001105spoe_handle_healthcheck_response(char *frame, size_t size, char *err, int errlen)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001106{
Christopher Faulet42bfa462017-01-04 14:14:19 +01001107 struct appctx appctx;
1108 struct spoe_appctx spoe_appctx;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001109
Christopher Faulet42bfa462017-01-04 14:14:19 +01001110 memset(&appctx, 0, sizeof(appctx));
1111 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001112
Christopher Faulet42bfa462017-01-04 14:14:19 +01001113 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001114 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001115
Christopher Faulet8ef75252017-02-20 22:56:03 +01001116 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1117 spoe_handle_agentdiscon_frame(&appctx, frame, size);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001118 goto error;
1119 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001120 if (spoe_handle_agenthello_frame(&appctx, frame, size) <= 0)
1121 goto error;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001122
1123 return 0;
1124
1125 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001126 if (SPOE_APPCTX(&appctx)->status_code >= SPOE_FRM_ERRS)
1127 SPOE_APPCTX(&appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
1128 strncpy(err, spoe_frm_err_reasons[SPOE_APPCTX(&appctx)->status_code], errlen);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001129 return -1;
1130}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001131
Christopher Fauleta1cda022016-12-21 08:58:06 +01001132/* Send a SPOE frame to an agent. It returns -1 when an error occurred, 0 when
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05001133 * the frame can be ignored, 1 to retry later, and the frame length on
Christopher Fauleta1cda022016-12-21 08:58:06 +01001134 * success. */
1135static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001136spoe_send_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001137{
1138 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001139 int ret;
1140 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001141
Christopher Faulet8ef75252017-02-20 22:56:03 +01001142 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1143 * length. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001144 netint = htonl(framesz);
1145 memcpy(buf, (char *)&netint, 4);
Willy Tarreau06d80a92017-10-19 14:32:15 +02001146 ret = ci_putblk(si_ic(si), buf, framesz+4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001147 if (ret <= 0) {
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001148 if ((ret == -3 && b_is_null(&si_ic(si)->buf)) || ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001149 si_rx_room_blk(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001150 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001151 }
1152 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001153 return -1; /* error */
1154 }
1155 return framesz;
1156}
1157
1158/* Receive a SPOE frame from an agent. It return -1 when an error occurred, 0
1159 * when the frame can be ignored, 1 to retry later and the frame length on
1160 * success. */
1161static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001162spoe_recv_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001163{
1164 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001165 int ret;
1166 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001167
Willy Tarreau06d80a92017-10-19 14:32:15 +02001168 ret = co_getblk(si_oc(si), (char *)&netint, 4, 0);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001169 if (ret > 0) {
1170 framesz = ntohl(netint);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001171 if (framesz > SPOE_APPCTX(appctx)->max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001172 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001173 return -1;
1174 }
Willy Tarreau06d80a92017-10-19 14:32:15 +02001175 ret = co_getblk(si_oc(si), buf, framesz, 4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001176 }
1177 if (ret <= 0) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001178 if (ret == 0) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001179 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001180 }
1181 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001182 return -1; /* error */
1183 }
1184 return framesz;
1185}
1186
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001187/********************************************************************
1188 * Functions that manage the SPOE applet
1189 ********************************************************************/
Christopher Faulet4596fb72017-01-11 14:05:19 +01001190static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001191spoe_wakeup_appctx(struct appctx *appctx)
Christopher Faulet4596fb72017-01-11 14:05:19 +01001192{
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001193 si_want_get(appctx->owner);
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001194 si_rx_endp_more(appctx->owner);
Christopher Faulet4596fb72017-01-11 14:05:19 +01001195 appctx_wakeup(appctx);
1196 return 1;
1197}
1198
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001199/* Callback function that catches applet timeouts. If a timeout occurred, we set
1200 * <appctx->st1> flag and the SPOE applet is woken up. */
1201static struct task *
Willy Tarreau144f84a2021-03-02 16:09:26 +01001202spoe_process_appctx(struct task * task, void *context, unsigned int state)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001203{
Olivier Houchard9f6af332018-05-25 14:04:04 +02001204 struct appctx *appctx = context;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001205
1206 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1207 if (tick_is_expired(task->expire, now_ms)) {
1208 task->expire = TICK_ETERNITY;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001209 appctx->st1 = SPOE_APPCTX_ERR_TOUT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001210 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001211 spoe_wakeup_appctx(appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001212 return task;
1213}
1214
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001215/* Callback function that releases a SPOE applet. This happens when the
1216 * connection with the agent is closed. */
1217static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001218spoe_release_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001219{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001220 struct stream_interface *si = appctx->owner;
1221 struct spoe_appctx *spoe_appctx = SPOE_APPCTX(appctx);
1222 struct spoe_agent *agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001223 struct spoe_context *ctx, *back;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001224
1225 if (spoe_appctx == NULL)
1226 return;
1227
1228 appctx->ctx.spoe.ptr = NULL;
1229 agent = spoe_appctx->agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001230
1231 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p\n",
1232 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1233 __FUNCTION__, appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001234
Christopher Faulet8ef75252017-02-20 22:56:03 +01001235 /* Remove applet from the list of running applets */
Willy Tarreau4781b152021-04-06 13:53:36 +02001236 _HA_ATOMIC_DEC(&agent->counters.applets);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001237 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001238 if (!LIST_ISEMPTY(&spoe_appctx->list)) {
Willy Tarreau2b718102021-04-21 07:32:39 +02001239 LIST_DELETE(&spoe_appctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001240 LIST_INIT(&spoe_appctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001241 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001242 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001243
Christopher Faulet8ef75252017-02-20 22:56:03 +01001244 /* Shutdown the server connection, if needed */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001245 if (appctx->st0 != SPOE_APPCTX_ST_END) {
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001246 if (appctx->st0 == SPOE_APPCTX_ST_IDLE) {
1247 eb32_delete(&spoe_appctx->node);
Willy Tarreau4781b152021-04-06 13:53:36 +02001248 _HA_ATOMIC_DEC(&agent->counters.idles);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001249 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001250
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001251 appctx->st0 = SPOE_APPCTX_ST_END;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001252 if (spoe_appctx->status_code == SPOE_FRM_ERR_NONE)
1253 spoe_appctx->status_code = SPOE_FRM_ERR_IO;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001254
1255 si_shutw(si);
1256 si_shutr(si);
1257 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001258 }
1259
Christopher Faulet8ef75252017-02-20 22:56:03 +01001260 /* Destroy the task attached to this applet */
Willy Tarreauf6562792019-05-07 19:05:35 +02001261 task_destroy(spoe_appctx->task);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001262
Christopher Faulet8ef75252017-02-20 22:56:03 +01001263 /* Notify all waiting streams */
1264 list_for_each_entry_safe(ctx, back, &spoe_appctx->waiting_queue, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02001265 LIST_DELETE(&ctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001266 LIST_INIT(&ctx->list);
Willy Tarreau4781b152021-04-06 13:53:36 +02001267 _HA_ATOMIC_DEC(&agent->counters.nb_waiting);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001268 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauletcf181c72020-11-10 18:45:34 +01001269 ctx->spoe_appctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001270 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001271 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001272 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001273 }
1274
Christopher Faulet8ef75252017-02-20 22:56:03 +01001275 /* If the applet was processing a fragmented frame, notify the
1276 * corresponding stream. */
1277 if (spoe_appctx->frag_ctx.ctx) {
1278 ctx = spoe_appctx->frag_ctx.ctx;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001279 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001280 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001281 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001282 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1283 }
1284
Willy Tarreaub042e4f2022-02-15 16:49:37 +01001285 if (!LIST_ISEMPTY(&agent->rt[tid].waiting_queue)) {
Christopher Fauletcf181c72020-11-10 18:45:34 +01001286 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
1287 if (ctx->spoe_appctx == spoe_appctx)
1288 ctx->spoe_appctx = NULL;
1289 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001290 goto end;
Christopher Fauletcf181c72020-11-10 18:45:34 +01001291 }
Christopher Faulet6f1296b2021-08-02 17:53:56 +02001292 else {
1293 /* It is the last running applet and the sending and waiting
1294 * queues are not empty. Try to start a new one if HAproxy is
1295 * not stopping.
1296 */
1297 if (!stopping &&
1298 (!LIST_ISEMPTY(&agent->rt[tid].sending_queue) || !LIST_ISEMPTY(&agent->rt[tid].waiting_queue)) &&
1299 spoe_create_appctx(agent->spoe_conf))
1300 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001301
Christopher Faulet6f1296b2021-08-02 17:53:56 +02001302 /* otherwise, notify all waiting streams */
1303 list_for_each_entry_safe(ctx, back, &agent->rt[tid].sending_queue, list) {
1304 LIST_DELETE(&ctx->list);
1305 LIST_INIT(&ctx->list);
1306 _HA_ATOMIC_DEC(&agent->counters.nb_sending);
1307 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
1308 ctx->spoe_appctx = NULL;
1309 ctx->state = SPOE_CTX_ST_ERROR;
1310 ctx->status_code = (spoe_appctx->status_code + 0x100);
1311 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1312 }
1313 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
1314 LIST_DELETE(&ctx->list);
1315 LIST_INIT(&ctx->list);
1316 _HA_ATOMIC_DEC(&agent->counters.nb_waiting);
1317 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
1318 ctx->spoe_appctx = NULL;
1319 ctx->state = SPOE_CTX_ST_ERROR;
1320 ctx->status_code = (spoe_appctx->status_code + 0x100);
1321 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1322 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001323 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001324
1325 end:
Christopher Faulet55ae8a62019-05-23 22:47:48 +02001326 /* Release allocated memory */
1327 spoe_release_buffer(&spoe_appctx->buffer,
1328 &spoe_appctx->buffer_wait);
1329 pool_free(pool_head_spoe_appctx, spoe_appctx);
1330
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001331 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001332 agent->rt[tid].frame_size = agent->max_frame_size;
1333 list_for_each_entry(spoe_appctx, &agent->rt[tid].applets, list)
1334 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, spoe_appctx->max_frame_size);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001335}
1336
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001337static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001338spoe_handle_connect_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001339{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001340 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001341 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001342 char *frame, *buf;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001343 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001344
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001345 if (si_state_in(si->state, SI_SB_CER|SI_SB_DIS|SI_SB_CLO)) {
1346 /* closed */
1347 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1348 goto exit;
1349 }
1350
Willy Tarreau4f283fa2019-06-05 14:34:03 +02001351 if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST)) {
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001352 /* not connected yet */
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001353 si_rx_endp_more(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001354 task_wakeup(si_strm(si)->task, TASK_WOKEN_MSG);
1355 goto stop;
1356 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001357
Christopher Fauleta1cda022016-12-21 08:58:06 +01001358 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001359 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1360 " - Connection timed out\n",
1361 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1362 __FUNCTION__, appctx);
1363 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001364 goto exit;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001365 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001366
Christopher Faulet42bfa462017-01-04 14:14:19 +01001367 if (SPOE_APPCTX(appctx)->task->expire == TICK_ETERNITY)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001368 SPOE_APPCTX(appctx)->task->expire =
1369 tick_add_ifset(now_ms, agent->timeout.hello);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001370
Christopher Faulet8ef75252017-02-20 22:56:03 +01001371 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1372 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001373 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001374 ret = spoe_prepare_hahello_frame(appctx, frame,
1375 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001376 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001377 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001378
1379 switch (ret) {
1380 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001381 case 0: /* ignore => an error, cannot be ignored */
1382 goto exit;
1383
1384 case 1: /* retry later */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001385 goto stop;
1386
Christopher Faulet8ef75252017-02-20 22:56:03 +01001387 default:
1388 /* HELLO frame successfully sent, now wait for the
1389 * reply. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001390 appctx->st0 = SPOE_APPCTX_ST_CONNECTING;
1391 goto next;
1392 }
1393
1394 next:
1395 return 0;
1396 stop:
1397 return 1;
1398 exit:
1399 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1400 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001401}
1402
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001403static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001404spoe_handle_connecting_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001405{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001406 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001407 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001408 char *frame;
1409 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001410
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001411
Christopher Fauletb067b062017-01-04 16:39:11 +01001412 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001413 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001414 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001415 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001416
Christopher Fauleta1cda022016-12-21 08:58:06 +01001417 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001418 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1419 " - Connection timed out\n",
1420 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1421 __FUNCTION__, appctx);
1422 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001423 goto exit;
1424 }
1425
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001426 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001427 ret = spoe_recv_frame(appctx, frame,
1428 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001429 if (ret > 1) {
1430 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1431 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1432 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001433 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001434 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001435 ret = spoe_handle_agenthello_frame(appctx, frame, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001436 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001437
Christopher Fauleta1cda022016-12-21 08:58:06 +01001438 switch (ret) {
1439 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001440 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001441 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1442 goto next;
1443
1444 case 1: /* retry later */
1445 goto stop;
1446
1447 default:
Willy Tarreau4781b152021-04-06 13:53:36 +02001448 _HA_ATOMIC_INC(&agent->counters.idles);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001449 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001450 SPOE_APPCTX(appctx)->node.key = 0;
1451 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001452
1453 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001454 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001455 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001456 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001457
Christopher Fauleta1cda022016-12-21 08:58:06 +01001458 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001459 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001460 if (trash.data)
1461 co_skip(si_oc(si), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001462
1463 SPOE_APPCTX(appctx)->task->expire =
1464 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001465 return 0;
1466 stop:
1467 return 1;
1468 exit:
1469 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1470 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001471}
1472
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001473
Christopher Fauleta1cda022016-12-21 08:58:06 +01001474static int
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001475spoe_handle_sending_frame_appctx(struct appctx *appctx, int *skip)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001476{
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001477 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
1478 struct spoe_context *ctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001479 char *frame, *buf;
1480 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001481
Christopher Faulet8ef75252017-02-20 22:56:03 +01001482 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1483 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001484 buf = trash.area; frame = buf+4;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001485
1486 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY) {
1487 ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
1488 ret = spoe_prepare_hafrag_frame(appctx, ctx, frame,
1489 SPOE_APPCTX(appctx)->max_frame_size);
1490 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001491 else if (LIST_ISEMPTY(&agent->rt[tid].sending_queue)) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001492 *skip = 1;
1493 ret = 1;
1494 goto end;
1495 }
1496 else {
Christopher Faulet24289f22017-09-25 14:48:02 +02001497 ctx = LIST_NEXT(&agent->rt[tid].sending_queue, typeof(ctx), list);
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001498 ret = spoe_prepare_hanotify_frame(appctx, ctx, frame,
1499 SPOE_APPCTX(appctx)->max_frame_size);
1500
1501 }
1502
Christopher Faulet8ef75252017-02-20 22:56:03 +01001503 if (ret > 1)
1504 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001505
Christopher Faulet8ef75252017-02-20 22:56:03 +01001506 switch (ret) {
1507 case -1: /* error */
1508 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1509 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001510
Christopher Faulet8ef75252017-02-20 22:56:03 +01001511 case 0: /* ignore */
1512 if (ctx == NULL)
1513 goto abort_frag_frame;
1514
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001515 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Willy Tarreau2b718102021-04-21 07:32:39 +02001516 LIST_DELETE(&ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001517 LIST_INIT(&ctx->list);
Willy Tarreau4781b152021-04-06 13:53:36 +02001518 _HA_ATOMIC_DEC(&agent->counters.nb_sending);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001519 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001520 ctx->spoe_appctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001521 ctx->state = SPOE_CTX_ST_ERROR;
1522 ctx->status_code = (SPOE_APPCTX(appctx)->status_code + 0x100);
1523 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001524 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001525 break;
1526
1527 case 1: /* retry */
1528 *skip = 1;
1529 break;
1530
1531 default:
1532 if (ctx == NULL)
1533 goto abort_frag_frame;
1534
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001535 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Willy Tarreau2b718102021-04-21 07:32:39 +02001536 LIST_DELETE(&ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001537 LIST_INIT(&ctx->list);
Willy Tarreau4781b152021-04-06 13:53:36 +02001538 _HA_ATOMIC_DEC(&agent->counters.nb_sending);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001539 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001540 ctx->spoe_appctx = SPOE_APPCTX(appctx);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001541 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) ||
1542 (ctx->frag_ctx.flags & SPOE_FRM_FL_FIN))
1543 goto no_frag_frame_sent;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001544 else
Christopher Faulet8ef75252017-02-20 22:56:03 +01001545 goto frag_frame_sent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001546 }
1547 goto end;
1548
1549 frag_frame_sent:
1550 appctx->st0 = SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001551 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001552 SPOE_APPCTX(appctx)->frag_ctx.ctx = ctx;
1553 SPOE_APPCTX(appctx)->frag_ctx.cursid = ctx->stream_id;
1554 SPOE_APPCTX(appctx)->frag_ctx.curfid = ctx->frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001555 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
1556 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1557 goto end;
1558
1559 no_frag_frame_sent:
1560 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
1561 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Willy Tarreau2b718102021-04-21 07:32:39 +02001562 LIST_APPEND(&agent->rt[tid].waiting_queue, &ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001563 }
1564 else if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_PIPELINING) {
1565 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Willy Tarreau2b718102021-04-21 07:32:39 +02001566 LIST_APPEND(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001567 }
1568 else {
1569 appctx->st0 = SPOE_APPCTX_ST_WAITING_SYNC_ACK;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001570 *skip = 1;
Willy Tarreau2b718102021-04-21 07:32:39 +02001571 LIST_APPEND(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001572 }
Willy Tarreau4781b152021-04-06 13:53:36 +02001573 _HA_ATOMIC_INC(&agent->counters.nb_waiting);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001574 ctx->stats.tv_wait = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001575 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1576 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1577 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001578 SPOE_APPCTX(appctx)->cur_fpa++;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001579
Christopher Faulet8ef75252017-02-20 22:56:03 +01001580 ctx->state = SPOE_CTX_ST_WAITING_ACK;
1581 goto end;
1582
1583 abort_frag_frame:
1584 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1585 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1586 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1587 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1588 goto end;
1589
1590 end:
1591 return ret;
1592}
1593
1594static int
1595spoe_handle_receiving_frame_appctx(struct appctx *appctx, int *skip)
1596{
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02001597 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001598 struct spoe_context *ctx = NULL;
1599 char *frame;
1600 int ret;
1601
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001602 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001603 ret = spoe_recv_frame(appctx, frame,
1604 SPOE_APPCTX(appctx)->max_frame_size);
1605 if (ret > 1) {
1606 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1607 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001608 ret = -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001609 goto end;
1610 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001611 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001612 ret = spoe_handle_agentack_frame(appctx, &ctx, frame, ret);
1613 }
1614 switch (ret) {
1615 case -1: /* error */
1616 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1617 break;
1618
1619 case 0: /* ignore */
1620 break;
1621
1622 case 1: /* retry */
1623 *skip = 1;
1624 break;
1625
1626 default:
Willy Tarreau2b718102021-04-21 07:32:39 +02001627 LIST_DELETE(&ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001628 LIST_INIT(&ctx->list);
Willy Tarreau4781b152021-04-06 13:53:36 +02001629 _HA_ATOMIC_DEC(&agent->counters.nb_waiting);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001630 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
1631 ctx->stats.tv_response = now;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001632 if (ctx->spoe_appctx) {
1633 ctx->spoe_appctx->cur_fpa--;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001634 ctx->spoe_appctx = NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001635 }
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001636 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY &&
1637 ctx == SPOE_APPCTX(appctx)->frag_ctx.ctx) {
1638 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1639 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1640 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1641 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1642 }
1643 else if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1644 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001645 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1646 break;
1647 }
1648
1649 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001650 if (trash.data)
1651 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001652 end:
1653 return ret;
1654}
1655
1656static int
1657spoe_handle_processing_appctx(struct appctx *appctx)
1658{
1659 struct stream_interface *si = appctx->owner;
Christopher Fauletd7da3dd2021-08-02 18:13:27 +02001660 struct server *srv = objt_server(si_strm(si)->target);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001661 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Fauletd7da3dd2021-08-02 18:13:27 +02001662 int ret, skip_sending = 0, skip_receiving = 0, active_s = 0, active_r = 0, close_asap = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001663
1664 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
1665 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1666 goto exit;
1667 }
1668
1669 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
1670 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
1671 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1672 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1673 goto next;
1674 }
1675
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001676 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001677 " - process: fpa=%u/%u - appctx-state=%s - weight=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001678 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8f82b202018-01-24 16:23:03 +01001679 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->cur_fpa,
1680 agent->max_fpa, spoe_appctx_state_str[appctx->st0],
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001681 SPOE_APPCTX(appctx)->node.key, SPOE_APPCTX(appctx)->flags);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001682
Christopher Fauletd7da3dd2021-08-02 18:13:27 +02001683
1684 /* Close the applet ASAP because some sessions are waiting for a free
1685 * connection slot. It is only an issue in multithreaded mode.
1686 */
1687 close_asap = (global.nbthread > 1 &&
1688 (agent->b.be->queue.length ||
1689 (srv && (srv->queue.length || (srv->maxconn && srv->served >= srv_dynamic_maxconn(srv))))));
1690
1691 /* Don"t try to send new frame we are waiting for at lease a ack, in
1692 * sync mode or if applet must be closed ASAP
1693 */
1694 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK || (close_asap && SPOE_APPCTX(appctx)->cur_fpa))
Christopher Faulet8f82b202018-01-24 16:23:03 +01001695 skip_sending = 1;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001696
Christopher Faulet8f82b202018-01-24 16:23:03 +01001697 /* receiving_frame loop */
1698 while (!skip_receiving) {
1699 ret = spoe_handle_receiving_frame_appctx(appctx, &skip_receiving);
1700 switch (ret) {
1701 case -1: /* error */
1702 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001703
Christopher Faulet8f82b202018-01-24 16:23:03 +01001704 case 0: /* ignore */
1705 active_r = 1;
1706 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001707
Christopher Faulet8f82b202018-01-24 16:23:03 +01001708 case 1: /* retry */
1709 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001710
Christopher Faulet8f82b202018-01-24 16:23:03 +01001711 default:
1712 active_r = 1;
1713 break;
1714 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001715 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001716
Christopher Faulet8f82b202018-01-24 16:23:03 +01001717 /* send_frame loop */
1718 while (!skip_sending && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
1719 ret = spoe_handle_sending_frame_appctx(appctx, &skip_sending);
1720 switch (ret) {
1721 case -1: /* error */
1722 goto next;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001723
Christopher Faulet8f82b202018-01-24 16:23:03 +01001724 case 0: /* ignore */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001725 if (SPOE_APPCTX(appctx)->node.key)
1726 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001727 active_s++;
1728 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001729
Christopher Faulet8f82b202018-01-24 16:23:03 +01001730 case 1: /* retry */
1731 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001732
Christopher Faulet8f82b202018-01-24 16:23:03 +01001733 default:
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001734 if (SPOE_APPCTX(appctx)->node.key)
1735 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001736 active_s++;
1737 break;
1738 }
Christopher Fauletd7da3dd2021-08-02 18:13:27 +02001739
1740 /* if applet must be close ASAP, don't send more than a frame */
1741 if (close_asap)
1742 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001743 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001744
Christopher Faulet8f82b202018-01-24 16:23:03 +01001745 if (active_s || active_r) {
Christopher Faulet8f82b202018-01-24 16:23:03 +01001746 update_freq_ctr(&agent->rt[tid].processing_per_sec, active_s);
1747 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1748 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001749
Christopher Faulet8f82b202018-01-24 16:23:03 +01001750 if (appctx->st0 == SPOE_APPCTX_ST_PROCESSING && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
Christopher Fauletd7da3dd2021-08-02 18:13:27 +02001751 /* If applet must be closed, don't switch it in IDLE state and
1752 * close it when the last waiting frame is acknowledged.
Christopher Faulet9e647e52021-03-01 15:01:14 +01001753 */
Christopher Fauletd7da3dd2021-08-02 18:13:27 +02001754 if (close_asap) {
1755 if (SPOE_APPCTX(appctx)->cur_fpa)
1756 goto out;
Christopher Faulet9e647e52021-03-01 15:01:14 +01001757 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
1758 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1759 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1760 goto next;
1761 }
Willy Tarreau4781b152021-04-06 13:53:36 +02001762 _HA_ATOMIC_INC(&agent->counters.idles);
Christopher Faulet8f82b202018-01-24 16:23:03 +01001763 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001764 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001765 }
Christopher Fauletd7da3dd2021-08-02 18:13:27 +02001766
1767 out:
Christopher Fauleta1cda022016-12-21 08:58:06 +01001768 return 1;
1769
Christopher Faulet8f82b202018-01-24 16:23:03 +01001770 next:
1771 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1772 return 0;
1773
Christopher Fauleta1cda022016-12-21 08:58:06 +01001774 exit:
1775 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1776 return 0;
1777}
1778
1779static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001780spoe_handle_disconnect_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001781{
1782 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001783 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001784 char *frame, *buf;
1785 int ret;
Christopher Fauletb067b062017-01-04 16:39:11 +01001786
Christopher Fauleta1cda022016-12-21 08:58:06 +01001787 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO)
1788 goto exit;
1789
1790 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT)
1791 goto exit;
1792
Christopher Faulet8ef75252017-02-20 22:56:03 +01001793 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1794 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001795 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001796 ret = spoe_prepare_hadiscon_frame(appctx, frame,
1797 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001798 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001799 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001800
1801 switch (ret) {
1802 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001803 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001804 goto exit;
1805
1806 case 1: /* retry */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001807 goto stop;
1808
1809 default:
1810 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1811 " - disconnected by HAProxy (%d): %s\n",
1812 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001813 __FUNCTION__, appctx,
1814 SPOE_APPCTX(appctx)->status_code,
1815 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001816
1817 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1818 goto next;
1819 }
1820
1821 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001822 SPOE_APPCTX(appctx)->task->expire =
1823 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001824 return 0;
1825 stop:
1826 return 1;
1827 exit:
1828 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1829 return 0;
1830}
1831
1832static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001833spoe_handle_disconnecting_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001834{
1835 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001836 char *frame;
1837 int ret;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001838
Christopher Fauletb067b062017-01-04 16:39:11 +01001839 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001840 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001841 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001842 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001843
Christopher Fauletb067b062017-01-04 16:39:11 +01001844 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001845 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001846 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001847 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001848
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001849 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001850 ret = spoe_recv_frame(appctx, frame,
1851 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001852 if (ret > 1) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001853 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001854 ret = spoe_handle_agentdiscon_frame(appctx, frame, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001855 }
1856
1857 switch (ret) {
1858 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001859 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1860 " - error on frame (%s)\n",
1861 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001862 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Fauleta1cda022016-12-21 08:58:06 +01001863 __FUNCTION__, appctx,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001864 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001865 goto exit;
1866
1867 case 0: /* ignore */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001868 goto next;
1869
1870 case 1: /* retry */
1871 goto stop;
1872
1873 default:
Christopher Fauleta1cda022016-12-21 08:58:06 +01001874 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001875 " - disconnected by peer (%d): %.*s\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01001876 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001877 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001878 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->status_code,
1879 SPOE_APPCTX(appctx)->rlen, SPOE_APPCTX(appctx)->reason);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001880 goto exit;
1881 }
1882
1883 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001884 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001885 if (trash.data)
1886 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001887
Christopher Fauleta1cda022016-12-21 08:58:06 +01001888 return 0;
1889 stop:
1890 return 1;
1891 exit:
1892 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1893 return 0;
1894}
1895
1896/* I/O Handler processing messages exchanged with the agent */
1897static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001898spoe_handle_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001899{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001900 struct stream_interface *si = appctx->owner;
1901 struct spoe_agent *agent;
1902
1903 if (SPOE_APPCTX(appctx) == NULL)
1904 return;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001905
Christopher Faulet8ef75252017-02-20 22:56:03 +01001906 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
1907 agent = SPOE_APPCTX(appctx)->agent;
Christopher Fauletb067b062017-01-04 16:39:11 +01001908
Christopher Fauleta1cda022016-12-21 08:58:06 +01001909 switchstate:
1910 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1911 " - appctx-state=%s\n",
1912 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1913 __FUNCTION__, appctx, spoe_appctx_state_str[appctx->st0]);
1914
1915 switch (appctx->st0) {
1916 case SPOE_APPCTX_ST_CONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001917 if (spoe_handle_connect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001918 goto out;
1919 goto switchstate;
1920
1921 case SPOE_APPCTX_ST_CONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001922 if (spoe_handle_connecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001923 goto out;
1924 goto switchstate;
1925
1926 case SPOE_APPCTX_ST_IDLE:
Willy Tarreau4781b152021-04-06 13:53:36 +02001927 _HA_ATOMIC_DEC(&agent->counters.idles);
Christopher Faulet7d9f1ba2018-02-28 13:33:26 +01001928 eb32_delete(&SPOE_APPCTX(appctx)->node);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001929 if (stopping &&
Christopher Faulet24289f22017-09-25 14:48:02 +02001930 LIST_ISEMPTY(&agent->rt[tid].sending_queue) &&
Christopher Faulet42bfa462017-01-04 14:14:19 +01001931 LIST_ISEMPTY(&SPOE_APPCTX(appctx)->waiting_queue)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001932 SPOE_APPCTX(appctx)->task->expire =
1933 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001934 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001935 goto switchstate;
1936 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001937 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1938 /* fall through */
1939
1940 case SPOE_APPCTX_ST_PROCESSING:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001941 case SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY:
1942 case SPOE_APPCTX_ST_WAITING_SYNC_ACK:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001943 if (spoe_handle_processing_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001944 goto out;
1945 goto switchstate;
1946
1947 case SPOE_APPCTX_ST_DISCONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001948 if (spoe_handle_disconnect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001949 goto out;
1950 goto switchstate;
1951
1952 case SPOE_APPCTX_ST_DISCONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001953 if (spoe_handle_disconnecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001954 goto out;
1955 goto switchstate;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001956
1957 case SPOE_APPCTX_ST_EXIT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001958 appctx->st0 = SPOE_APPCTX_ST_END;
1959 SPOE_APPCTX(appctx)->task->expire = TICK_ETERNITY;
1960
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001961 si_shutw(si);
1962 si_shutr(si);
1963 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001964 /* fall through */
1965
1966 case SPOE_APPCTX_ST_END:
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001967 return;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001968 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001969 out:
Christopher Faulet24289f22017-09-25 14:48:02 +02001970 if (stopping)
1971 spoe_wakeup_appctx(appctx);
1972
Christopher Faulet42bfa462017-01-04 14:14:19 +01001973 if (SPOE_APPCTX(appctx)->task->expire != TICK_ETERNITY)
1974 task_queue(SPOE_APPCTX(appctx)->task);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001975}
1976
1977struct applet spoe_applet = {
1978 .obj_type = OBJ_TYPE_APPLET,
1979 .name = "<SPOE>", /* used for logging */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001980 .fct = spoe_handle_appctx,
1981 .release = spoe_release_appctx,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001982};
1983
1984/* Create a SPOE applet. On success, the created applet is returned, else
1985 * NULL. */
1986static struct appctx *
Christopher Faulet8ef75252017-02-20 22:56:03 +01001987spoe_create_appctx(struct spoe_config *conf)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001988{
1989 struct appctx *appctx;
1990 struct session *sess;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001991 struct stream *strm;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001992
Willy Tarreaue6124462021-09-13 10:07:38 +02001993 if ((appctx = appctx_new(&spoe_applet)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001994 goto out_error;
1995
Willy Tarreauc9ef9bc2021-03-22 21:04:50 +01001996 appctx->ctx.spoe.ptr = pool_zalloc(pool_head_spoe_appctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001997 if (SPOE_APPCTX(appctx) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001998 goto out_free_appctx;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001999
Christopher Faulet42bfa462017-01-04 14:14:19 +01002000 appctx->st0 = SPOE_APPCTX_ST_CONNECT;
Willy Tarreaubeeabf52021-10-01 18:23:30 +02002001 if ((SPOE_APPCTX(appctx)->task = task_new_here()) == NULL)
Christopher Faulet42bfa462017-01-04 14:14:19 +01002002 goto out_free_spoe_appctx;
2003
2004 SPOE_APPCTX(appctx)->owner = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002005 SPOE_APPCTX(appctx)->task->process = spoe_process_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002006 SPOE_APPCTX(appctx)->task->context = appctx;
2007 SPOE_APPCTX(appctx)->agent = conf->agent;
2008 SPOE_APPCTX(appctx)->version = 0;
2009 SPOE_APPCTX(appctx)->max_frame_size = conf->agent->max_frame_size;
2010 SPOE_APPCTX(appctx)->flags = 0;
Christopher Fauletb067b062017-01-04 16:39:11 +01002011 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002012 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01002013 SPOE_APPCTX(appctx)->cur_fpa = 0;
Christopher Faulet4596fb72017-01-11 14:05:19 +01002014
Willy Tarreau90f366b2021-02-20 11:49:49 +01002015 LIST_INIT(&SPOE_APPCTX(appctx)->buffer_wait.list);
Christopher Faulet4596fb72017-01-11 14:05:19 +01002016 SPOE_APPCTX(appctx)->buffer_wait.target = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002017 SPOE_APPCTX(appctx)->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002018
2019 LIST_INIT(&SPOE_APPCTX(appctx)->list);
2020 LIST_INIT(&SPOE_APPCTX(appctx)->waiting_queue);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002021
Willy Tarreau5820a362016-12-22 15:59:02 +01002022 sess = session_new(&conf->agent_fe, NULL, &appctx->obj_type);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002023 if (!sess)
2024 goto out_free_spoe;
2025
Christopher Faulet26256f82020-09-14 11:40:13 +02002026 if ((strm = stream_new(sess, &appctx->obj_type, &BUF_NULL)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002027 goto out_free_sess;
2028
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002029 stream_set_backend(strm, conf->agent->b.be);
2030
2031 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002032 si_cant_get(&strm->si[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002033 appctx_wakeup(appctx);
2034
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002035 strm->do_log = NULL;
2036 strm->res.flags |= CF_READ_DONTWAIT;
2037
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002038 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Willy Tarreau2b718102021-04-21 07:32:39 +02002039 LIST_APPEND(&conf->agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002040 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Willy Tarreau4781b152021-04-06 13:53:36 +02002041 _HA_ATOMIC_INC(&conf->agent->counters.applets);
Emeric Brun5f77fef2017-05-29 15:26:51 +02002042
Emeric Brunc60def82017-09-27 14:59:38 +02002043 task_wakeup(SPOE_APPCTX(appctx)->task, TASK_WOKEN_INIT);
Willy Tarreau87787ac2017-08-28 16:22:54 +02002044 task_wakeup(strm->task, TASK_WOKEN_INIT);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002045 return appctx;
2046
2047 /* Error unrolling */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002048 out_free_sess:
2049 session_free(sess);
2050 out_free_spoe:
Olivier Houchard3f795f72019-04-17 22:51:06 +02002051 task_destroy(SPOE_APPCTX(appctx)->task);
Christopher Faulet42bfa462017-01-04 14:14:19 +01002052 out_free_spoe_appctx:
Willy Tarreaubafbe012017-11-24 17:34:44 +01002053 pool_free(pool_head_spoe_appctx, SPOE_APPCTX(appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002054 out_free_appctx:
2055 appctx_free(appctx);
2056 out_error:
2057 return NULL;
2058}
2059
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002060static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002061spoe_queue_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002062{
2063 struct spoe_config *conf = FLT_CONF(ctx->filter);
2064 struct spoe_agent *agent = conf->agent;
2065 struct appctx *appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002066 struct spoe_appctx *spoe_appctx;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002067
Christopher Fauleta1cda022016-12-21 08:58:06 +01002068 /* Check if we need to create a new SPOE applet or not. */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002069 if (!eb_is_empty(&agent->rt[tid].idle_applets) &&
Christopher Fauleteccfa612020-06-22 15:32:14 +02002070 (agent->rt[tid].processing == 1 || agent->rt[tid].processing < read_freq_ctr(&agent->rt[tid].processing_per_sec)))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002071 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002072
2073 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauleta1cda022016-12-21 08:58:06 +01002074 " - try to create new SPOE appctx\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002075 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
2076 ctx->strm);
2077
Christopher Fauleta1cda022016-12-21 08:58:06 +01002078 /* Do not try to create a new applet if there is no server up for the
2079 * agent's backend. */
2080 if (!agent->b.be->srv_act && !agent->b.be->srv_bck) {
2081 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2082 " - cannot create SPOE appctx: no server up\n",
2083 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2084 __FUNCTION__, ctx->strm);
2085 goto end;
2086 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002087
Christopher Fauleta1cda022016-12-21 08:58:06 +01002088 /* Do not try to create a new applet if we have reached the maximum of
2089 * connection per seconds */
Christopher Faulet48026722016-11-16 15:01:12 +01002090 if (agent->cps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002091 if (!freq_ctr_remain(&agent->rt[tid].conn_per_sec, agent->cps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002092 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2093 " - cannot create SPOE appctx: max CPS reached\n",
2094 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2095 __FUNCTION__, ctx->strm);
2096 goto end;
2097 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002098 }
2099
Christopher Faulet8ef75252017-02-20 22:56:03 +01002100 appctx = spoe_create_appctx(conf);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002101 if (appctx == NULL) {
2102 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2103 " - failed to create SPOE appctx\n",
2104 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2105 __FUNCTION__, ctx->strm);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02002106 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01002107 "SPOE: [%s] failed to create SPOE applet\n",
2108 agent->id);
2109
Christopher Fauleta1cda022016-12-21 08:58:06 +01002110 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002111 }
2112
Christopher Fauleta1cda022016-12-21 08:58:06 +01002113 /* Increase the per-process number of cumulated connections */
2114 if (agent->cps_max > 0)
Christopher Faulet24289f22017-09-25 14:48:02 +02002115 update_freq_ctr(&agent->rt[tid].conn_per_sec, 1);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002116
Christopher Fauleta1cda022016-12-21 08:58:06 +01002117 end:
2118 /* The only reason to return an error is when there is no applet */
Christopher Faulet24289f22017-09-25 14:48:02 +02002119 if (LIST_ISEMPTY(&agent->rt[tid].applets)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002120 ctx->status_code = SPOE_CTX_ERR_RES;
2121 return -1;
2122 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002123
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002124 /* Add the SPOE context in the sending queue if the stream has no applet
2125 * already assigned and wakeup all idle applets. Otherwise, don't queue
2126 * it. */
Willy Tarreau4781b152021-04-06 13:53:36 +02002127 _HA_ATOMIC_INC(&agent->counters.nb_sending);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002128 spoe_update_stat_time(&ctx->stats.tv_request, &ctx->stats.t_request);
2129 ctx->stats.tv_queue = now;
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002130 if (ctx->spoe_appctx)
2131 return 1;
Willy Tarreau2b718102021-04-21 07:32:39 +02002132 LIST_APPEND(&agent->rt[tid].sending_queue, &ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002133
2134 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002135 " - Add stream in sending queue"
Christopher Faulet68db0232018-04-06 11:34:12 +02002136 " - applets=%u - idles=%u - processing=%u\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002137 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
Christopher Faulet68db0232018-04-06 11:34:12 +02002138 ctx->strm, agent->counters.applets, agent->counters.idles,
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002139 agent->rt[tid].processing);
Christopher Fauletf7a30922016-11-10 15:04:51 +01002140
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002141 /* Finally try to wakeup an IDLE applet. */
2142 if (!eb_is_empty(&agent->rt[tid].idle_applets)) {
2143 struct eb32_node *node;
2144
2145 node = eb32_first(&agent->rt[tid].idle_applets);
2146 spoe_appctx = eb32_entry(node, struct spoe_appctx, node);
2147 if (node && spoe_appctx) {
2148 eb32_delete(&spoe_appctx->node);
2149 spoe_appctx->node.key++;
2150 eb32_insert(&agent->rt[tid].idle_applets, &spoe_appctx->node);
2151 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002152 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002153 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002154 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002155}
2156
2157/***************************************************************************
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002158 * Functions that encode SPOE messages
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002159 **************************************************************************/
Christopher Faulet10e37672017-09-21 16:38:22 +02002160/* Encode a SPOE message. Info in <ctx->frag_ctx>, if any, are used to handle
2161 * fragmented_content. If the next message can be processed, it returns 0. If
2162 * the message is too big, it returns -1.*/
2163static int
2164spoe_encode_message(struct stream *s, struct spoe_context *ctx,
2165 struct spoe_message *msg, int dir,
2166 char **buf, char *end)
2167{
2168 struct sample *smp;
2169 struct spoe_arg *arg;
2170 int ret;
2171
2172 if (msg->cond) {
2173 ret = acl_exec_cond(msg->cond, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2174 ret = acl_pass(ret);
2175 if (msg->cond->pol == ACL_COND_UNLESS)
2176 ret = !ret;
2177
2178 /* the rule does not match */
2179 if (!ret)
2180 goto next;
2181 }
2182
2183 /* Resume encoding of a SPOE argument */
2184 if (ctx->frag_ctx.curarg != NULL) {
2185 arg = ctx->frag_ctx.curarg;
2186 goto encode_argument;
2187 }
2188
2189 if (ctx->frag_ctx.curoff != UINT_MAX)
2190 goto encode_msg_payload;
2191
2192 /* Check if there is enough space for the message name and the
2193 * number of arguments. It implies <msg->id_len> is encoded on 2
2194 * bytes, at most (< 2288). */
2195 if (*buf + 2 + msg->id_len + 1 > end)
2196 goto too_big;
2197
2198 /* Encode the message name */
2199 if (spoe_encode_buffer(msg->id, msg->id_len, buf, end) == -1)
2200 goto too_big;
2201
2202 /* Set the number of arguments for this message */
2203 **buf = msg->nargs;
2204 (*buf)++;
2205
2206 ctx->frag_ctx.curoff = 0;
2207 encode_msg_payload:
2208
2209 /* Loop on arguments */
2210 list_for_each_entry(arg, &msg->args, list) {
2211 ctx->frag_ctx.curarg = arg;
2212 ctx->frag_ctx.curoff = UINT_MAX;
Kevin Zhuf7f54282019-04-26 14:00:01 +08002213 ctx->frag_ctx.curlen = 0;
Christopher Faulet10e37672017-09-21 16:38:22 +02002214
2215 encode_argument:
2216 if (ctx->frag_ctx.curoff != UINT_MAX)
2217 goto encode_arg_value;
2218
Joseph Herlantf7f60312018-11-15 13:46:49 -08002219 /* Encode the argument name as a string. It can by NULL */
Christopher Faulet10e37672017-09-21 16:38:22 +02002220 if (spoe_encode_buffer(arg->name, arg->name_len, buf, end) == -1)
2221 goto too_big;
2222
2223 ctx->frag_ctx.curoff = 0;
2224 encode_arg_value:
2225
Joseph Herlantf7f60312018-11-15 13:46:49 -08002226 /* Fetch the argument value */
Christopher Faulet10e37672017-09-21 16:38:22 +02002227 smp = sample_process(s->be, s->sess, s, dir|SMP_OPT_FINAL, arg->expr, NULL);
Christopher Faulet3b1d0042019-05-06 09:53:10 +02002228 if (smp) {
2229 smp->ctx.a[0] = &ctx->frag_ctx.curlen;
2230 smp->ctx.a[1] = &ctx->frag_ctx.curoff;
2231 }
Christopher Faulet85db3212019-04-26 14:30:15 +02002232 ret = spoe_encode_data(smp, buf, end);
Christopher Faulet10e37672017-09-21 16:38:22 +02002233 if (ret == -1 || ctx->frag_ctx.curoff)
2234 goto too_big;
2235 }
2236
2237 next:
2238 return 0;
2239
2240 too_big:
2241 return -1;
2242}
2243
Christopher Fauletc718b822017-09-21 16:50:56 +02002244/* Encode list of SPOE messages. Info in <ctx->frag_ctx>, if any, are used to
2245 * handle fragmented content. On success it returns 1. If an error occurred, -1
2246 * is returned. If nothing has been encoded, it returns 0 (this is only possible
2247 * for unfragmented payload). */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002248static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002249spoe_encode_messages(struct stream *s, struct spoe_context *ctx,
Christopher Fauletc718b822017-09-21 16:50:56 +02002250 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002251{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002252 struct spoe_config *conf = FLT_CONF(ctx->filter);
2253 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002254 struct spoe_message *msg;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002255 char *p, *end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002256
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002257 p = b_head(&ctx->buffer);
Christopher Faulet24289f22017-09-25 14:48:02 +02002258 end = p + agent->rt[tid].frame_size - FRAME_HDR_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002259
Christopher Fauletc718b822017-09-21 16:50:56 +02002260 if (type == SPOE_MSGS_BY_EVENT) { /* Loop on messages by event */
2261 /* Resume encoding of a SPOE message */
2262 if (ctx->frag_ctx.curmsg != NULL) {
2263 msg = ctx->frag_ctx.curmsg;
2264 goto encode_evt_message;
2265 }
2266
2267 list_for_each_entry(msg, messages, by_evt) {
2268 ctx->frag_ctx.curmsg = msg;
2269 ctx->frag_ctx.curarg = NULL;
2270 ctx->frag_ctx.curoff = UINT_MAX;
2271
2272 encode_evt_message:
2273 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2274 goto too_big;
2275 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002276 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002277 else if (type == SPOE_MSGS_BY_GROUP) { /* Loop on messages by group */
2278 /* Resume encoding of a SPOE message */
2279 if (ctx->frag_ctx.curmsg != NULL) {
2280 msg = ctx->frag_ctx.curmsg;
2281 goto encode_grp_message;
2282 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002283
Christopher Fauletc718b822017-09-21 16:50:56 +02002284 list_for_each_entry(msg, messages, by_grp) {
2285 ctx->frag_ctx.curmsg = msg;
2286 ctx->frag_ctx.curarg = NULL;
2287 ctx->frag_ctx.curoff = UINT_MAX;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002288
Christopher Fauletc718b822017-09-21 16:50:56 +02002289 encode_grp_message:
2290 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2291 goto too_big;
2292 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002293 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002294 else
2295 goto skip;
2296
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002297
Christopher Faulet57583e42017-09-04 15:41:09 +02002298 /* nothing has been encoded for an unfragmented payload */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002299 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) && p == b_head(&ctx->buffer))
Christopher Faulet57583e42017-09-04 15:41:09 +02002300 goto skip;
2301
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002302 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002303 " - encode %s messages - spoe_appctx=%p"
2304 "- max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002305 (int)now.tv_sec, (int)now.tv_usec,
2306 agent->id, __FUNCTION__, s,
2307 ((ctx->flags & SPOE_CTX_FL_FRAGMENTED) ? "last fragment of" : "unfragmented"),
Christopher Fauletfce747b2018-01-24 15:59:32 +01002308 ctx->spoe_appctx, (agent->rt[tid].frame_size - FRAME_HDR_SIZE),
Christopher Faulet45073512018-07-20 10:16:29 +02002309 p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002310
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002311 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002312 ctx->frag_ctx.curmsg = NULL;
2313 ctx->frag_ctx.curarg = NULL;
2314 ctx->frag_ctx.curoff = 0;
2315 ctx->frag_ctx.flags = SPOE_FRM_FL_FIN;
Christopher Faulet57583e42017-09-04 15:41:09 +02002316
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002317 return 1;
2318
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002319 too_big:
Christopher Fauleta715ea82019-04-10 14:21:51 +02002320 /* Return an error if fragmentation is unsupported or if nothing has
2321 * been encoded because its too big and not splittable. */
2322 if (!(agent->flags & SPOE_FL_SND_FRAGMENTATION) || p == b_head(&ctx->buffer)) {
Christopher Fauletcecd8522017-02-24 22:11:21 +01002323 ctx->status_code = SPOE_CTX_ERR_TOO_BIG;
2324 return -1;
2325 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002326
2327 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002328 " - encode fragmented messages - spoe_appctx=%p"
2329 " - curmsg=%p - curarg=%p - curoff=%u"
2330 " - max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002331 (int)now.tv_sec, (int)now.tv_usec,
Christopher Fauletfce747b2018-01-24 15:59:32 +01002332 agent->id, __FUNCTION__, s, ctx->spoe_appctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002333 ctx->frag_ctx.curmsg, ctx->frag_ctx.curarg, ctx->frag_ctx.curoff,
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002334 (agent->rt[tid].frame_size - FRAME_HDR_SIZE), p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002335
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002336 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002337 ctx->flags |= SPOE_CTX_FL_FRAGMENTED;
2338 ctx->frag_ctx.flags &= ~SPOE_FRM_FL_FIN;
2339 return 1;
Christopher Faulet57583e42017-09-04 15:41:09 +02002340
2341 skip:
2342 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2343 " - skip the frame because nothing has been encoded\n",
2344 (int)now.tv_sec, (int)now.tv_usec,
2345 agent->id, __FUNCTION__, s);
2346 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002347}
2348
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002349
2350/***************************************************************************
2351 * Functions that handle SPOE actions
2352 **************************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002353/* Helper function to set a variable */
2354static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002355spoe_set_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002356 struct sample *smp)
2357{
2358 struct spoe_config *conf = FLT_CONF(ctx->filter);
2359 struct spoe_agent *agent = conf->agent;
2360 char varname[64];
2361
2362 memset(varname, 0, sizeof(varname));
2363 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2364 scope, agent->var_pfx, len, name);
Etienne Carriereaec89892017-12-14 09:36:40 +00002365 if (agent->flags & SPOE_FL_FORCE_SET_VAR)
2366 vars_set_by_name(varname, len, smp);
2367 else
2368 vars_set_by_name_ifexist(varname, len, smp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002369}
2370
2371/* Helper function to unset a variable */
2372static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002373spoe_unset_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002374 struct sample *smp)
2375{
2376 struct spoe_config *conf = FLT_CONF(ctx->filter);
2377 struct spoe_agent *agent = conf->agent;
2378 char varname[64];
2379
2380 memset(varname, 0, sizeof(varname));
2381 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2382 scope, agent->var_pfx, len, name);
2383 vars_unset_by_name_ifexist(varname, len, smp);
2384}
2385
2386
Christopher Faulet8ef75252017-02-20 22:56:03 +01002387static inline int
2388spoe_decode_action_set_var(struct stream *s, struct spoe_context *ctx,
2389 char **buf, char *end, int dir)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002390{
Christopher Faulet8ef75252017-02-20 22:56:03 +01002391 char *str, *scope, *p = *buf;
2392 struct sample smp;
2393 uint64_t sz;
2394 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002395
Christopher Faulet8ef75252017-02-20 22:56:03 +01002396 if (p + 2 >= end)
2397 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002398
Christopher Faulet8ef75252017-02-20 22:56:03 +01002399 /* SET-VAR requires 3 arguments */
2400 if (*p++ != 3)
2401 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002402
Christopher Faulet8ef75252017-02-20 22:56:03 +01002403 switch (*p++) {
2404 case SPOE_SCOPE_PROC: scope = "proc"; break;
2405 case SPOE_SCOPE_SESS: scope = "sess"; break;
2406 case SPOE_SCOPE_TXN : scope = "txn"; break;
2407 case SPOE_SCOPE_REQ : scope = "req"; break;
2408 case SPOE_SCOPE_RES : scope = "res"; break;
2409 default: goto skip;
2410 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002411
Christopher Faulet8ef75252017-02-20 22:56:03 +01002412 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2413 goto skip;
2414 memset(&smp, 0, sizeof(smp));
2415 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002416
Christopher Faulet8ef75252017-02-20 22:56:03 +01002417 if (spoe_decode_data(&p, end, &smp) == -1)
2418 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002419
Christopher Faulet8ef75252017-02-20 22:56:03 +01002420 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2421 " - set-var '%s.%s.%.*s'\n",
2422 (int)now.tv_sec, (int)now.tv_usec,
2423 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2424 __FUNCTION__, s, scope,
2425 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2426 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002427
Christopher Faulet2469eba2020-10-15 16:08:30 +02002428 if (smp.data.type == SMP_T_ANY)
2429 spoe_unset_var(ctx, scope, str, sz, &smp);
2430 else
2431 spoe_set_var(ctx, scope, str, sz, &smp);
Christopher Fauletb5cff602016-11-24 14:53:22 +01002432
Christopher Faulet8ef75252017-02-20 22:56:03 +01002433 ret = (p - *buf);
2434 *buf = p;
2435 return ret;
2436 skip:
2437 return 0;
2438}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002439
Christopher Faulet8ef75252017-02-20 22:56:03 +01002440static inline int
2441spoe_decode_action_unset_var(struct stream *s, struct spoe_context *ctx,
2442 char **buf, char *end, int dir)
2443{
2444 char *str, *scope, *p = *buf;
2445 struct sample smp;
2446 uint64_t sz;
2447 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002448
Christopher Faulet8ef75252017-02-20 22:56:03 +01002449 if (p + 2 >= end)
2450 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002451
Christopher Faulet8ef75252017-02-20 22:56:03 +01002452 /* UNSET-VAR requires 2 arguments */
2453 if (*p++ != 2)
2454 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002455
Christopher Faulet8ef75252017-02-20 22:56:03 +01002456 switch (*p++) {
2457 case SPOE_SCOPE_PROC: scope = "proc"; break;
2458 case SPOE_SCOPE_SESS: scope = "sess"; break;
2459 case SPOE_SCOPE_TXN : scope = "txn"; break;
2460 case SPOE_SCOPE_REQ : scope = "req"; break;
2461 case SPOE_SCOPE_RES : scope = "res"; break;
2462 default: goto skip;
2463 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002464
Christopher Faulet8ef75252017-02-20 22:56:03 +01002465 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2466 goto skip;
2467 memset(&smp, 0, sizeof(smp));
2468 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002469
Christopher Faulet8ef75252017-02-20 22:56:03 +01002470 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2471 " - unset-var '%s.%s.%.*s'\n",
2472 (int)now.tv_sec, (int)now.tv_usec,
2473 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2474 __FUNCTION__, s, scope,
2475 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2476 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002477
Christopher Faulet8ef75252017-02-20 22:56:03 +01002478 spoe_unset_var(ctx, scope, str, sz, &smp);
2479
2480 ret = (p - *buf);
2481 *buf = p;
2482 return ret;
2483 skip:
2484 return 0;
2485}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002486
Christopher Faulet8ef75252017-02-20 22:56:03 +01002487/* Process SPOE actions for a specific event. It returns 1 on success. If an
2488 * error occurred, 0 is returned. */
2489static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002490spoe_process_actions(struct stream *s, struct spoe_context *ctx, int dir)
Christopher Faulet8ef75252017-02-20 22:56:03 +01002491{
2492 char *p, *end;
2493 int ret;
2494
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002495 p = b_head(&ctx->buffer);
2496 end = p + b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002497
2498 while (p < end) {
2499 enum spoe_action_type type;
2500
2501 type = *p++;
2502 switch (type) {
2503 case SPOE_ACT_T_SET_VAR:
2504 ret = spoe_decode_action_set_var(s, ctx, &p, end, dir);
2505 if (!ret)
2506 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002507 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002508
Christopher Faulet8ef75252017-02-20 22:56:03 +01002509 case SPOE_ACT_T_UNSET_VAR:
2510 ret = spoe_decode_action_unset_var(s, ctx, &p, end, dir);
2511 if (!ret)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002512 goto skip;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002513 break;
2514
2515 default:
2516 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002517 }
2518 }
2519
2520 return 1;
2521 skip:
2522 return 0;
2523}
2524
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002525/***************************************************************************
2526 * Functions that process SPOE events
2527 **************************************************************************/
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002528static void
2529spoe_update_stats(struct stream *s, struct spoe_agent *agent,
2530 struct spoe_context *ctx, int dir)
2531{
2532 if (!tv_iszero(&ctx->stats.tv_start)) {
2533 spoe_update_stat_time(&ctx->stats.tv_start, &ctx->stats.t_process);
2534 ctx->stats.t_total += ctx->stats.t_process;
2535 tv_zero(&ctx->stats.tv_request);
2536 tv_zero(&ctx->stats.tv_queue);
2537 tv_zero(&ctx->stats.tv_wait);
2538 tv_zero(&ctx->stats.tv_response);
2539 }
2540
2541 if (agent->var_t_process) {
2542 struct sample smp;
2543
2544 memset(&smp, 0, sizeof(smp));
2545 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2546 smp.data.u.sint = ctx->stats.t_process;
2547 smp.data.type = SMP_T_SINT;
2548
2549 spoe_set_var(ctx, "txn", agent->var_t_process,
2550 strlen(agent->var_t_process), &smp);
2551 }
2552
2553 if (agent->var_t_total) {
2554 struct sample smp;
2555
2556 memset(&smp, 0, sizeof(smp));
2557 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2558 smp.data.u.sint = ctx->stats.t_total;
2559 smp.data.type = SMP_T_SINT;
2560
2561 spoe_set_var(ctx, "txn", agent->var_t_total,
2562 strlen(agent->var_t_total), &smp);
2563 }
2564}
2565
2566static void
2567spoe_handle_processing_error(struct stream *s, struct spoe_agent *agent,
2568 struct spoe_context *ctx, int dir)
2569{
2570 if (agent->eps_max > 0)
2571 update_freq_ctr(&agent->rt[tid].err_per_sec, 1);
2572
2573 if (agent->var_on_error) {
2574 struct sample smp;
2575
2576 memset(&smp, 0, sizeof(smp));
2577 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2578 smp.data.u.sint = ctx->status_code;
2579 smp.data.type = SMP_T_BOOL;
2580
2581 spoe_set_var(ctx, "txn", agent->var_on_error,
2582 strlen(agent->var_on_error), &smp);
2583 }
2584
2585 ctx->state = ((agent->flags & SPOE_FL_CONT_ON_ERR)
2586 ? SPOE_CTX_ST_READY
2587 : SPOE_CTX_ST_NONE);
2588}
2589
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002590static inline int
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002591spoe_start_processing(struct spoe_agent *agent, struct spoe_context *ctx, int dir)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002592{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002593 /* If a process is already started for this SPOE context, retry
2594 * later. */
2595 if (ctx->flags & SPOE_CTX_FL_PROCESS)
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002596 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002597
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002598 agent->rt[tid].processing++;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002599 ctx->stats.tv_start = now;
2600 ctx->stats.tv_request = now;
2601 ctx->stats.t_request = -1;
2602 ctx->stats.t_queue = -1;
2603 ctx->stats.t_waiting = -1;
2604 ctx->stats.t_response = -1;
2605 ctx->stats.t_process = -1;
2606
2607 ctx->status_code = 0;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002608
Christopher Fauleta1cda022016-12-21 08:58:06 +01002609 /* Set the right flag to prevent request and response processing
2610 * in same time. */
2611 ctx->flags |= ((dir == SMP_OPT_DIR_REQ)
2612 ? SPOE_CTX_FL_REQ_PROCESS
2613 : SPOE_CTX_FL_RSP_PROCESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002614 return 1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002615}
2616
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002617static inline void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002618spoe_stop_processing(struct spoe_agent *agent, struct spoe_context *ctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002619{
Christopher Fauletfce747b2018-01-24 15:59:32 +01002620 struct spoe_appctx *sa = ctx->spoe_appctx;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002621
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002622 if (!(ctx->flags & SPOE_CTX_FL_PROCESS))
2623 return;
Willy Tarreau4781b152021-04-06 13:53:36 +02002624 _HA_ATOMIC_INC(&agent->counters.nb_processed);
Christopher Faulet879dca92018-03-23 11:53:24 +01002625 if (sa) {
2626 if (sa->frag_ctx.ctx == ctx) {
2627 sa->frag_ctx.ctx = NULL;
2628 spoe_wakeup_appctx(sa->owner);
2629 }
2630 else
2631 sa->cur_fpa--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002632 }
2633
Christopher Fauleta1cda022016-12-21 08:58:06 +01002634 /* Reset the flag to allow next processing */
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002635 agent->rt[tid].processing--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002636 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002637
2638 /* Reset processing timer */
2639 ctx->process_exp = TICK_ETERNITY;
2640
Christopher Faulet8ef75252017-02-20 22:56:03 +01002641 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002642
Christopher Fauletfce747b2018-01-24 15:59:32 +01002643 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002644 ctx->frag_ctx.curmsg = NULL;
2645 ctx->frag_ctx.curarg = NULL;
2646 ctx->frag_ctx.curoff = 0;
2647 ctx->frag_ctx.flags = 0;
2648
Christopher Fauleta1cda022016-12-21 08:58:06 +01002649 if (!LIST_ISEMPTY(&ctx->list)) {
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002650 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS)
Willy Tarreau4781b152021-04-06 13:53:36 +02002651 _HA_ATOMIC_DEC(&agent->counters.nb_sending);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002652 else
Willy Tarreau4781b152021-04-06 13:53:36 +02002653 _HA_ATOMIC_DEC(&agent->counters.nb_waiting);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002654
Willy Tarreau2b718102021-04-21 07:32:39 +02002655 LIST_DELETE(&ctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002656 LIST_INIT(&ctx->list);
2657 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002658}
2659
Christopher Faulet58d03682017-09-21 16:57:24 +02002660/* Process a list of SPOE messages. First, this functions will process messages
2661 * and send them to an agent in a NOTIFY frame. Then, it will wait a ACK frame
2662 * to process corresponding actions. During all the processing, it returns 0
2663 * and it returns 1 when the processing is finished. If an error occurred, -1
2664 * is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002665static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002666spoe_process_messages(struct stream *s, struct spoe_context *ctx,
2667 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002668{
Christopher Fauletf7a30922016-11-10 15:04:51 +01002669 struct spoe_config *conf = FLT_CONF(ctx->filter);
2670 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002671 int ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002672
2673 if (ctx->state == SPOE_CTX_ST_ERROR)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002674 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002675
2676 if (tick_is_expired(ctx->process_exp, now_ms) && ctx->state != SPOE_CTX_ST_DONE) {
2677 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002678 " - failed to process messages: timeout\n",
Christopher Fauletf7a30922016-11-10 15:04:51 +01002679 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002680 agent->id, __FUNCTION__, s);
Christopher Fauletb067b062017-01-04 16:39:11 +01002681 ctx->status_code = SPOE_CTX_ERR_TOUT;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002682 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002683 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002684
2685 if (ctx->state == SPOE_CTX_ST_READY) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002686 if (agent->eps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002687 if (!freq_ctr_remain(&agent->rt[tid].err_per_sec, agent->eps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002688 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002689 " - skip processing of messages: max EPS reached\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002690 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002691 agent->id, __FUNCTION__, s);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002692 goto skip;
2693 }
2694 }
2695
Christopher Fauletf7a30922016-11-10 15:04:51 +01002696 if (!tick_isset(ctx->process_exp)) {
2697 ctx->process_exp = tick_add_ifset(now_ms, agent->timeout.processing);
2698 s->task->expire = tick_first((tick_is_expired(s->task->expire, now_ms) ? 0 : s->task->expire),
2699 ctx->process_exp);
2700 }
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002701 ret = spoe_start_processing(agent, ctx, dir);
Christopher Fauletb067b062017-01-04 16:39:11 +01002702 if (!ret)
2703 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002704
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002705 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002706 /* fall through */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002707 }
2708
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002709 if (ctx->state == SPOE_CTX_ST_ENCODING_MSGS) {
Christopher Faulet63263e52019-04-10 14:47:18 +02002710 if (tv_iszero(&ctx->stats.tv_request))
2711 ctx->stats.tv_request = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002712 if (!spoe_acquire_buffer(&ctx->buffer, &ctx->buffer_wait))
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002713 goto out;
Christopher Faulet58d03682017-09-21 16:57:24 +02002714 ret = spoe_encode_messages(s, ctx, messages, dir, type);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002715 if (ret < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002716 goto end;
Christopher Faulet57583e42017-09-04 15:41:09 +02002717 if (!ret)
2718 goto skip;
Christopher Faulet333694d2018-01-12 10:45:47 +01002719 if (spoe_queue_context(ctx) < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002720 goto end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002721 ctx->state = SPOE_CTX_ST_SENDING_MSGS;
2722 }
2723
2724 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS) {
Christopher Fauletfce747b2018-01-24 15:59:32 +01002725 if (ctx->spoe_appctx)
2726 spoe_wakeup_appctx(ctx->spoe_appctx->owner);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002727 ret = 0;
2728 goto out;
2729 }
2730
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002731 if (ctx->state == SPOE_CTX_ST_WAITING_ACK) {
2732 ret = 0;
2733 goto out;
2734 }
2735
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002736 if (ctx->state == SPOE_CTX_ST_DONE) {
Christopher Faulet58d03682017-09-21 16:57:24 +02002737 spoe_process_actions(s, ctx, dir);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002738 ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002739 ctx->frame_id++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002740 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002741 spoe_update_stat_time(&ctx->stats.tv_response, &ctx->stats.t_response);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002742 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002743 }
2744
2745 out:
2746 return ret;
2747
Christopher Fauleta1cda022016-12-21 08:58:06 +01002748 skip:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002749 tv_zero(&ctx->stats.tv_start);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002750 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002751 spoe_stop_processing(agent, ctx);
2752 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002753
Christopher Fauleta1cda022016-12-21 08:58:06 +01002754 end:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002755 spoe_update_stats(s, agent, ctx, dir);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002756 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002757 if (ctx->status_code) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002758 _HA_ATOMIC_INC(&agent->counters.nb_errors);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002759 spoe_handle_processing_error(s, agent, ctx, dir);
2760 ret = 1;
2761 }
Christopher Faulet58d03682017-09-21 16:57:24 +02002762 return ret;
2763}
2764
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002765/* Process a SPOE group, ie the list of messages attached to the group <grp>.
2766 * See spoe_process_message for details. */
2767static int
2768spoe_process_group(struct stream *s, struct spoe_context *ctx,
2769 struct spoe_group *group, int dir)
2770{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002771 struct spoe_config *conf = FLT_CONF(ctx->filter);
2772 struct spoe_agent *agent = conf->agent;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002773 int ret;
2774
2775 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2776 " - ctx-state=%s - Process messages for group=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002777 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002778 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2779 group->id);
2780
2781 if (LIST_ISEMPTY(&group->messages))
2782 return 1;
2783
2784 ret = spoe_process_messages(s, ctx, &group->messages, dir, SPOE_MSGS_BY_GROUP);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002785 if (ret && ctx->stats.t_process != -1) {
2786 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002787 " - <GROUP:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu %u/%u\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002788 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002789 __FUNCTION__, s, group->id, s->uniq_id, ctx->status_code,
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002790 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002791 ctx->stats.t_response, ctx->stats.t_process,
2792 agent->counters.idles, agent->counters.applets,
2793 agent->counters.nb_sending, agent->counters.nb_waiting,
2794 agent->counters.nb_errors, agent->counters.nb_processed,
2795 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2796 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2797 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2798 "SPOE: [%s] <GROUP:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2799 agent->id, group->id, s->uniq_id, ctx->status_code,
2800 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2801 ctx->stats.t_response, ctx->stats.t_process,
2802 agent->counters.idles, agent->counters.applets,
2803 agent->counters.nb_sending, agent->counters.nb_waiting,
2804 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002805 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002806 return ret;
2807}
2808
Christopher Faulet58d03682017-09-21 16:57:24 +02002809/* Process a SPOE event, ie the list of messages attached to the event <ev>.
2810 * See spoe_process_message for details. */
2811static int
2812spoe_process_event(struct stream *s, struct spoe_context *ctx,
2813 enum spoe_event ev)
2814{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002815 struct spoe_config *conf = FLT_CONF(ctx->filter);
2816 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002817 int dir, ret;
2818
2819 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002820 " - ctx-state=%s - Process messages for event=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002821 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet58d03682017-09-21 16:57:24 +02002822 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2823 spoe_event_str[ev]);
2824
2825 dir = ((ev < SPOE_EV_ON_SERVER_SESS) ? SMP_OPT_DIR_REQ : SMP_OPT_DIR_RES);
2826
2827 if (LIST_ISEMPTY(&(ctx->events[ev])))
2828 return 1;
2829
2830 ret = spoe_process_messages(s, ctx, &(ctx->events[ev]), dir, SPOE_MSGS_BY_EVENT);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002831 if (ret && ctx->stats.t_process != -1) {
2832 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002833 " - <EVENT:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu %u/%u\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002834 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2835 __FUNCTION__, s, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2836 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002837 ctx->stats.t_response, ctx->stats.t_process,
2838 agent->counters.idles, agent->counters.applets,
2839 agent->counters.nb_sending, agent->counters.nb_waiting,
2840 agent->counters.nb_errors, agent->counters.nb_processed,
2841 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2842 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2843 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2844 "SPOE: [%s] <EVENT:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2845 agent->id, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2846 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2847 ctx->stats.t_response, ctx->stats.t_process,
2848 agent->counters.idles, agent->counters.applets,
2849 agent->counters.nb_sending, agent->counters.nb_waiting,
2850 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002851 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002852 return ret;
2853}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002854
2855/***************************************************************************
2856 * Functions that create/destroy SPOE contexts
2857 **************************************************************************/
Christopher Fauleta1cda022016-12-21 08:58:06 +01002858static int
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002859spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002860{
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002861 if (buf->size)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002862 return 1;
2863
Willy Tarreau2b718102021-04-21 07:32:39 +02002864 if (LIST_INLIST(&buffer_wait->list))
Willy Tarreau90f366b2021-02-20 11:49:49 +01002865 LIST_DEL_INIT(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002866
Willy Tarreaud68d4f12021-03-22 14:44:31 +01002867 if (b_alloc(buf))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002868 return 1;
2869
Willy Tarreaub4e34762021-09-30 19:02:18 +02002870 LIST_APPEND(&th_ctx->buffer_wq, &buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002871 return 0;
2872}
2873
2874static void
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002875spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002876{
Willy Tarreau2b718102021-04-21 07:32:39 +02002877 if (LIST_INLIST(&buffer_wait->list))
Willy Tarreau90f366b2021-02-20 11:49:49 +01002878 LIST_DEL_INIT(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002879
2880 /* Release the buffer if needed */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002881 if (buf->size) {
Christopher Faulet4596fb72017-01-11 14:05:19 +01002882 b_free(buf);
Willy Tarreau4d77bbf2021-02-20 12:02:46 +01002883 offer_buffers(buffer_wait->target, 1);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002884 }
2885}
2886
Christopher Faulet4596fb72017-01-11 14:05:19 +01002887static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002888spoe_wakeup_context(struct spoe_context *ctx)
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002889{
2890 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
2891 return 1;
2892}
2893
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002894static struct spoe_context *
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002895spoe_create_context(struct stream *s, struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002896{
2897 struct spoe_config *conf = FLT_CONF(filter);
2898 struct spoe_context *ctx;
2899
Willy Tarreauc9ef9bc2021-03-22 21:04:50 +01002900 ctx = pool_zalloc(pool_head_spoe_ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002901 if (ctx == NULL) {
2902 return NULL;
2903 }
Christopher Fauletb067b062017-01-04 16:39:11 +01002904 ctx->filter = filter;
2905 ctx->state = SPOE_CTX_ST_NONE;
2906 ctx->status_code = SPOE_CTX_ERR_NONE;
2907 ctx->flags = 0;
Christopher Faulet11610f32017-09-21 10:23:10 +02002908 ctx->events = conf->agent->events;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02002909 ctx->groups = &conf->agent->groups;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002910 ctx->buffer = BUF_NULL;
Willy Tarreau90f366b2021-02-20 11:49:49 +01002911 LIST_INIT(&ctx->buffer_wait.list);
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002912 ctx->buffer_wait.target = ctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002913 ctx->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_context;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002914 LIST_INIT(&ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002915
Christopher Fauletf7a30922016-11-10 15:04:51 +01002916 ctx->stream_id = 0;
2917 ctx->frame_id = 1;
2918 ctx->process_exp = TICK_ETERNITY;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002919
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002920 tv_zero(&ctx->stats.tv_start);
2921 tv_zero(&ctx->stats.tv_request);
2922 tv_zero(&ctx->stats.tv_queue);
2923 tv_zero(&ctx->stats.tv_wait);
2924 tv_zero(&ctx->stats.tv_response);
2925 ctx->stats.t_request = -1;
2926 ctx->stats.t_queue = -1;
2927 ctx->stats.t_waiting = -1;
2928 ctx->stats.t_response = -1;
2929 ctx->stats.t_process = -1;
2930 ctx->stats.t_total = 0;
2931
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002932 ctx->strm = s;
2933 ctx->state = SPOE_CTX_ST_READY;
2934 filter->ctx = ctx;
2935
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002936 return ctx;
2937}
2938
2939static void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002940spoe_destroy_context(struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002941{
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002942 struct spoe_config *conf = FLT_CONF(filter);
2943 struct spoe_context *ctx = filter->ctx;
2944
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002945 if (!ctx)
2946 return;
2947
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002948 spoe_stop_processing(conf->agent, ctx);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002949 pool_free(pool_head_spoe_ctx, ctx);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002950 filter->ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002951}
2952
2953static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002954spoe_reset_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002955{
2956 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01002957 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002958
2959 tv_zero(&ctx->stats.tv_start);
2960 tv_zero(&ctx->stats.tv_request);
2961 tv_zero(&ctx->stats.tv_queue);
2962 tv_zero(&ctx->stats.tv_wait);
2963 tv_zero(&ctx->stats.tv_response);
2964 ctx->stats.t_request = -1;
2965 ctx->stats.t_queue = -1;
2966 ctx->stats.t_waiting = -1;
2967 ctx->stats.t_response = -1;
2968 ctx->stats.t_process = -1;
2969 ctx->stats.t_total = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002970}
2971
2972
2973/***************************************************************************
2974 * Hooks that manage the filter lifecycle (init/check/deinit)
2975 **************************************************************************/
2976/* Signal handler: Do a soft stop, wakeup SPOE applet */
2977static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002978spoe_sig_stop(struct sig_handler *sh)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002979{
2980 struct proxy *p;
2981
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002982 p = proxies_list;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002983 while (p) {
2984 struct flt_conf *fconf;
2985
2986 list_for_each_entry(fconf, &p->filter_configs, list) {
Christopher Faulet3b386a32017-02-23 10:17:15 +01002987 struct spoe_config *conf;
2988 struct spoe_agent *agent;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002989 struct spoe_appctx *spoe_appctx;
Christopher Faulet24289f22017-09-25 14:48:02 +02002990 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002991
Christopher Faulet3b386a32017-02-23 10:17:15 +01002992 if (fconf->id != spoe_filter_id)
2993 continue;
2994
2995 conf = fconf->conf;
2996 agent = conf->agent;
2997
Christopher Faulet24289f22017-09-25 14:48:02 +02002998 for (i = 0; i < global.nbthread; ++i) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002999 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02003000 list_for_each_entry(spoe_appctx, &agent->rt[i].applets, list)
3001 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003002 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003003 }
3004 }
3005 p = p->next;
3006 }
3007}
3008
3009
3010/* Initialize the SPOE filter. Returns -1 on error, else 0. */
3011static int
3012spoe_init(struct proxy *px, struct flt_conf *fconf)
3013{
3014 struct spoe_config *conf = fconf->conf;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003015
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003016 /* conf->agent_fe was already initialized during the config
3017 * parsing. Finish initialization. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003018 conf->agent_fe.last_change = now.tv_sec;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003019 conf->agent_fe.cap = PR_CAP_FE;
3020 conf->agent_fe.mode = PR_MODE_TCP;
3021 conf->agent_fe.maxconn = 0;
3022 conf->agent_fe.options2 |= PR_O2_INDEPSTR;
3023 conf->agent_fe.conn_retries = CONN_RETRIES;
3024 conf->agent_fe.accept = frontend_accept;
3025 conf->agent_fe.srv = NULL;
3026 conf->agent_fe.timeout.client = TICK_ETERNITY;
3027 conf->agent_fe.default_target = &spoe_applet.obj_type;
3028 conf->agent_fe.fe_req_ana = AN_REQ_SWITCHING_RULES;
3029
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003030 if (!sighandler_registered) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003031 signal_register_fct(0, spoe_sig_stop, 0);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003032 sighandler_registered = 1;
3033 }
3034
Christopher Faulet00292352019-01-09 15:05:10 +01003035 fconf->flags |= FLT_CFG_FL_HTX;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003036 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003037}
3038
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003039/* Free resources allocated by the SPOE filter. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003040static void
3041spoe_deinit(struct proxy *px, struct flt_conf *fconf)
3042{
3043 struct spoe_config *conf = fconf->conf;
3044
3045 if (conf) {
3046 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003047
Christopher Faulet8ef75252017-02-20 22:56:03 +01003048 spoe_release_agent(agent);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003049 free(conf->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003050 free(conf);
3051 }
3052 fconf->conf = NULL;
3053}
3054
3055/* Check configuration of a SPOE filter for a specified proxy.
3056 * Return 1 on error, else 0. */
3057static int
3058spoe_check(struct proxy *px, struct flt_conf *fconf)
3059{
Christopher Faulet7ee86672017-09-19 11:08:28 +02003060 struct flt_conf *f;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003061 struct spoe_config *conf = fconf->conf;
3062 struct proxy *target;
Christopher Faulet1d7d0f82021-02-19 10:56:41 +01003063 struct logsrv *logsrv;
Willy Tarreaub0769b22019-02-07 13:40:33 +01003064 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003065
Christopher Faulet7ee86672017-09-19 11:08:28 +02003066 /* Check all SPOE filters for proxy <px> to be sure all SPOE agent names
3067 * are uniq */
3068 list_for_each_entry(f, &px->filter_configs, list) {
3069 struct spoe_config *c = f->conf;
3070
3071 /* This is not an SPOE filter */
3072 if (f->id != spoe_filter_id)
3073 continue;
3074 /* This is the current SPOE filter */
3075 if (f == fconf)
3076 continue;
3077
3078 /* Check engine Id. It should be uniq */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003079 if (strcmp(conf->id, c->id) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003080 ha_alert("Proxy %s : duplicated name for SPOE engine '%s'.\n",
3081 px->id, conf->id);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003082 return 1;
3083 }
3084 }
3085
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003086 target = proxy_be_by_name(conf->agent->b.name);
3087 if (target == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003088 ha_alert("Proxy %s : unknown backend '%s' used by SPOE agent '%s'"
3089 " declared at %s:%d.\n",
3090 px->id, conf->agent->b.name, conf->agent->id,
3091 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003092 return 1;
3093 }
3094 if (target->mode != PR_MODE_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003095 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3096 " at %s:%d does not support HTTP mode.\n",
3097 px->id, target->id, conf->agent->id,
3098 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003099 return 1;
3100 }
3101
Christopher Fauletfe261552019-03-18 13:57:42 +01003102 if ((conf->agent->rt = calloc(global.nbthread, sizeof(*conf->agent->rt))) == NULL) {
Willy Tarreaub0769b22019-02-07 13:40:33 +01003103 ha_alert("Proxy %s : out of memory initializing SPOE agent '%s' declared at %s:%d.\n",
3104 px->id, conf->agent->id, conf->agent->conf.file, conf->agent->conf.line);
3105 return 1;
3106 }
3107 for (i = 0; i < global.nbthread; ++i) {
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003108 conf->agent->rt[i].engine_id = NULL;
Christopher Fauletfe261552019-03-18 13:57:42 +01003109 conf->agent->rt[i].frame_size = conf->agent->max_frame_size;
3110 conf->agent->rt[i].processing = 0;
3111 LIST_INIT(&conf->agent->rt[i].applets);
3112 LIST_INIT(&conf->agent->rt[i].sending_queue);
3113 LIST_INIT(&conf->agent->rt[i].waiting_queue);
3114 HA_SPIN_INIT(&conf->agent->rt[i].lock);
Willy Tarreaub0769b22019-02-07 13:40:33 +01003115 }
3116
Christopher Faulet1d7d0f82021-02-19 10:56:41 +01003117 list_for_each_entry(logsrv, &conf->agent_fe.logsrvs, list) {
3118 if (logsrv->type == LOG_TARGET_BUFFER) {
3119 struct sink *sink = sink_find(logsrv->ring_name);
3120
3121 if (!sink || sink->type != SINK_TYPE_BUFFER) {
3122 ha_alert("Proxy %s : log server used by SPOE agent '%s' declared"
Ilya Shipitsind7a988c2021-03-04 23:26:15 +05003123 " at %s:%d uses unknown ring named '%s'.\n",
Christopher Faulet1d7d0f82021-02-19 10:56:41 +01003124 px->id, conf->agent->id, conf->agent->conf.file,
3125 conf->agent->conf.line, logsrv->ring_name);
3126 return 1;
3127 }
3128 logsrv->sink = sink;
3129 }
3130 }
3131
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003132 ha_free(&conf->agent->b.name);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003133 conf->agent->b.be = target;
3134 return 0;
3135}
3136
Kevin Zhud87b1a52019-09-17 15:05:45 +02003137/* Initializes the SPOE filter for a proxy for a specific thread.
3138 * Returns a negative value if an error occurs. */
3139static int
3140spoe_init_per_thread(struct proxy *p, struct flt_conf *fconf)
3141{
3142 struct spoe_config *conf = fconf->conf;
3143 struct spoe_agent *agent = conf->agent;
3144
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003145 agent->rt[tid].engine_id = generate_pseudo_uuid();
3146 if (agent->rt[tid].engine_id == NULL)
3147 return -1;
Kevin Zhud87b1a52019-09-17 15:05:45 +02003148 return 0;
3149}
3150
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003151/**************************************************************************
3152 * Hooks attached to a stream
3153 *************************************************************************/
3154/* Called when a filter instance is created and attach to a stream. It creates
3155 * the context that will be used to process this stream. */
3156static int
3157spoe_start(struct stream *s, struct filter *filter)
3158{
Christopher Faulet72bcc472017-01-04 16:39:41 +01003159 struct spoe_config *conf = FLT_CONF(filter);
3160 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003161 struct spoe_context *ctx;
3162
3163 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
Christopher Faulet72bcc472017-01-04 16:39:41 +01003164 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003165 __FUNCTION__, s);
3166
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003167 if ((ctx = spoe_create_context(s, filter)) == NULL) {
Christopher Faulet72bcc472017-01-04 16:39:41 +01003168 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
3169 " - failed to create SPOE context\n",
3170 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletccbc3fd2017-09-15 11:51:18 +02003171 __FUNCTION__, s);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02003172 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01003173 "SPOE: [%s] failed to create SPOE context\n",
3174 agent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003175 return 0;
3176 }
3177
Christopher Faulet11610f32017-09-21 10:23:10 +02003178 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003179 filter->pre_analyzers |= AN_REQ_INSPECT_FE;
3180
Christopher Faulet11610f32017-09-21 10:23:10 +02003181 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003182 filter->pre_analyzers |= AN_REQ_INSPECT_BE;
3183
Christopher Faulet11610f32017-09-21 10:23:10 +02003184 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003185 filter->pre_analyzers |= AN_RES_INSPECT;
3186
Christopher Faulet11610f32017-09-21 10:23:10 +02003187 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003188 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_FE;
3189
Christopher Faulet11610f32017-09-21 10:23:10 +02003190 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003191 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_BE;
3192
Christopher Faulet11610f32017-09-21 10:23:10 +02003193 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003194 filter->pre_analyzers |= AN_RES_HTTP_PROCESS_FE;
3195
3196 return 1;
3197}
3198
3199/* Called when a filter instance is detached from a stream. It release the
3200 * attached SPOE context. */
3201static void
3202spoe_stop(struct stream *s, struct filter *filter)
3203{
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003204 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
3205 (int)now.tv_sec, (int)now.tv_usec,
3206 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3207 __FUNCTION__, s);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003208 spoe_destroy_context(filter);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003209}
3210
Christopher Fauletf7a30922016-11-10 15:04:51 +01003211
3212/*
3213 * Called when the stream is woken up because of expired timer.
3214 */
3215static void
3216spoe_check_timeouts(struct stream *s, struct filter *filter)
3217{
3218 struct spoe_context *ctx = filter->ctx;
3219
Christopher Fauletac580602018-03-20 16:09:20 +01003220 if (tick_is_expired(ctx->process_exp, now_ms))
Christopher Fauleta73e59b2016-12-09 17:30:18 +01003221 s->pending_events |= TASK_WOKEN_MSG;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003222}
3223
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003224/* Called when we are ready to filter data on a channel */
3225static int
3226spoe_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3227{
3228 struct spoe_context *ctx = filter->ctx;
3229 int ret = 1;
3230
3231 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3232 " - ctx-flags=0x%08x\n",
3233 (int)now.tv_sec, (int)now.tv_usec,
3234 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3235 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3236
Christopher Fauletb067b062017-01-04 16:39:11 +01003237 if (ctx->state == SPOE_CTX_ST_NONE)
3238 goto out;
3239
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003240 if (!(chn->flags & CF_ISRESP)) {
3241 if (filter->pre_analyzers & AN_REQ_INSPECT_FE)
3242 chn->analysers |= AN_REQ_INSPECT_FE;
3243 if (filter->pre_analyzers & AN_REQ_INSPECT_BE)
3244 chn->analysers |= AN_REQ_INSPECT_BE;
3245
3246 if (ctx->flags & SPOE_CTX_FL_CLI_CONNECTED)
3247 goto out;
3248
3249 ctx->stream_id = s->uniq_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01003250 ret = spoe_process_event(s, ctx, SPOE_EV_ON_CLIENT_SESS);
Christopher Fauletb067b062017-01-04 16:39:11 +01003251 if (!ret)
3252 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003253 ctx->flags |= SPOE_CTX_FL_CLI_CONNECTED;
3254 }
3255 else {
Miroslav Zagorac88403262020-06-19 22:17:17 +02003256 if (filter->pre_analyzers & AN_RES_INSPECT)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003257 chn->analysers |= AN_RES_INSPECT;
3258
3259 if (ctx->flags & SPOE_CTX_FL_SRV_CONNECTED)
3260 goto out;
3261
Christopher Faulet8ef75252017-02-20 22:56:03 +01003262 ret = spoe_process_event(s, ctx, SPOE_EV_ON_SERVER_SESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003263 if (!ret) {
3264 channel_dont_read(chn);
3265 channel_dont_close(chn);
Christopher Fauletb067b062017-01-04 16:39:11 +01003266 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003267 }
Christopher Fauletb067b062017-01-04 16:39:11 +01003268 ctx->flags |= SPOE_CTX_FL_SRV_CONNECTED;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003269 }
3270
3271 out:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003272 return ret;
3273}
3274
3275/* Called before a processing happens on a given channel */
3276static int
3277spoe_chn_pre_analyze(struct stream *s, struct filter *filter,
3278 struct channel *chn, unsigned an_bit)
3279{
3280 struct spoe_context *ctx = filter->ctx;
3281 int ret = 1;
3282
3283 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3284 " - ctx-flags=0x%08x - ana=0x%08x\n",
3285 (int)now.tv_sec, (int)now.tv_usec,
3286 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3287 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
3288 ctx->flags, an_bit);
3289
Christopher Fauletb067b062017-01-04 16:39:11 +01003290 if (ctx->state == SPOE_CTX_ST_NONE)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003291 goto out;
3292
3293 switch (an_bit) {
3294 case AN_REQ_INSPECT_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003295 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003296 break;
3297 case AN_REQ_INSPECT_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003298 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003299 break;
3300 case AN_RES_INSPECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003301 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003302 break;
3303 case AN_REQ_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003304 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003305 break;
3306 case AN_REQ_HTTP_PROCESS_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003307 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003308 break;
3309 case AN_RES_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003310 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003311 break;
3312 }
3313
3314 out:
Christopher Faulet9cdca972018-02-01 08:45:45 +01003315 if (!ret && (chn->flags & CF_ISRESP)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003316 channel_dont_read(chn);
3317 channel_dont_close(chn);
3318 }
3319 return ret;
3320}
3321
3322/* Called when the filtering on the channel ends. */
3323static int
3324spoe_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3325{
3326 struct spoe_context *ctx = filter->ctx;
3327
3328 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3329 " - ctx-flags=0x%08x\n",
3330 (int)now.tv_sec, (int)now.tv_usec,
3331 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3332 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3333
3334 if (!(ctx->flags & SPOE_CTX_FL_PROCESS)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003335 spoe_reset_context(ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003336 }
3337
3338 return 1;
3339}
3340
3341/********************************************************************
3342 * Functions that manage the filter initialization
3343 ********************************************************************/
3344struct flt_ops spoe_ops = {
3345 /* Manage SPOE filter, called for each filter declaration */
3346 .init = spoe_init,
3347 .deinit = spoe_deinit,
3348 .check = spoe_check,
Kevin Zhud87b1a52019-09-17 15:05:45 +02003349 .init_per_thread = spoe_init_per_thread,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003350
3351 /* Handle start/stop of SPOE */
Christopher Fauletf7a30922016-11-10 15:04:51 +01003352 .attach = spoe_start,
3353 .detach = spoe_stop,
3354 .check_timeouts = spoe_check_timeouts,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003355
3356 /* Handle channels activity */
3357 .channel_start_analyze = spoe_start_analyze,
3358 .channel_pre_analyze = spoe_chn_pre_analyze,
3359 .channel_end_analyze = spoe_end_analyze,
3360};
3361
3362
3363static int
3364cfg_parse_spoe_agent(const char *file, int linenum, char **args, int kwm)
3365{
3366 const char *err;
3367 int i, err_code = 0;
3368
3369 if ((cfg_scope == NULL && curengine != NULL) ||
3370 (cfg_scope != NULL && curengine == NULL) ||
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003371 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope) != 0))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003372 goto out;
3373
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003374 if (strcmp(args[0], "spoe-agent") == 0) { /* new spoe-agent section */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003375 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003376 ha_alert("parsing [%s:%d] : missing name for spoe-agent section.\n",
3377 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003378 err_code |= ERR_ALERT | ERR_ABORT;
3379 goto out;
3380 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003381 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3382 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003383 goto out;
3384 }
3385
3386 err = invalid_char(args[1]);
3387 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003388 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3389 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003390 err_code |= ERR_ALERT | ERR_ABORT;
3391 goto out;
3392 }
3393
3394 if (curagent != NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003395 ha_alert("parsing [%s:%d] : another spoe-agent section previously defined.\n",
3396 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003397 err_code |= ERR_ALERT | ERR_ABORT;
3398 goto out;
3399 }
3400 if ((curagent = calloc(1, sizeof(*curagent))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003401 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003402 err_code |= ERR_ALERT | ERR_ABORT;
3403 goto out;
3404 }
3405
3406 curagent->id = strdup(args[1]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003407
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003408 curagent->conf.file = strdup(file);
3409 curagent->conf.line = linenum;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003410
3411 curagent->timeout.hello = TICK_ETERNITY;
3412 curagent->timeout.idle = TICK_ETERNITY;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003413 curagent->timeout.processing = TICK_ETERNITY;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003414
Christopher Fauleta1cda022016-12-21 08:58:06 +01003415 curagent->var_pfx = NULL;
3416 curagent->var_on_error = NULL;
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003417 curagent->var_t_process = NULL;
3418 curagent->var_t_total = NULL;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003419 curagent->flags = (SPOE_FL_ASYNC | SPOE_FL_PIPELINING | SPOE_FL_SND_FRAGMENTATION);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003420 curagent->cps_max = 0;
3421 curagent->eps_max = 0;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01003422 curagent->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01003423 curagent->max_fpa = 20;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003424
3425 for (i = 0; i < SPOE_EV_EVENTS; ++i)
Christopher Faulet11610f32017-09-21 10:23:10 +02003426 LIST_INIT(&curagent->events[i]);
3427 LIST_INIT(&curagent->groups);
3428 LIST_INIT(&curagent->messages);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003429 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003430 else if (strcmp(args[0], "use-backend") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003431 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003432 ha_alert("parsing [%s:%d] : '%s' expects a backend name.\n",
3433 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003434 err_code |= ERR_ALERT | ERR_FATAL;
3435 goto out;
3436 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003437 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003438 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003439 free(curagent->b.name);
3440 curagent->b.name = strdup(args[1]);
3441 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003442 else if (strcmp(args[0], "messages") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003443 int cur_arg = 1;
3444 while (*args[cur_arg]) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003445 struct spoe_placeholder *ph = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003446
Christopher Faulet11610f32017-09-21 10:23:10 +02003447 list_for_each_entry(ph, &curmphs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003448 if (strcmp(ph->id, args[cur_arg]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003449 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3450 file, linenum, args[cur_arg]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003451 err_code |= ERR_ALERT | ERR_FATAL;
3452 goto out;
3453 }
3454 }
3455
Christopher Faulet11610f32017-09-21 10:23:10 +02003456 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003457 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003458 err_code |= ERR_ALERT | ERR_ABORT;
3459 goto out;
3460 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003461 ph->id = strdup(args[cur_arg]);
Willy Tarreau2b718102021-04-21 07:32:39 +02003462 LIST_APPEND(&curmphs, &ph->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003463 cur_arg++;
3464 }
3465 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003466 else if (strcmp(args[0], "groups") == 0) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003467 int cur_arg = 1;
3468 while (*args[cur_arg]) {
3469 struct spoe_placeholder *ph = NULL;
3470
3471 list_for_each_entry(ph, &curgphs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003472 if (strcmp(ph->id, args[cur_arg]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003473 ha_alert("parsing [%s:%d]: spoe-group '%s' already used.\n",
3474 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003475 err_code |= ERR_ALERT | ERR_FATAL;
3476 goto out;
3477 }
3478 }
3479
3480 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003481 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003482 err_code |= ERR_ALERT | ERR_ABORT;
3483 goto out;
3484 }
3485 ph->id = strdup(args[cur_arg]);
Willy Tarreau2b718102021-04-21 07:32:39 +02003486 LIST_APPEND(&curgphs, &ph->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02003487 cur_arg++;
3488 }
3489 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003490 else if (strcmp(args[0], "timeout") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003491 unsigned int *tv = NULL;
3492 const char *res;
3493 unsigned timeout;
3494
3495 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003496 ha_alert("parsing [%s:%d] : 'timeout' expects 'hello', 'idle' and 'processing'.\n",
3497 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003498 err_code |= ERR_ALERT | ERR_FATAL;
3499 goto out;
3500 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003501 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3502 goto out;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003503 if (strcmp(args[1], "hello") == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003504 tv = &curagent->timeout.hello;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003505 else if (strcmp(args[1], "idle") == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003506 tv = &curagent->timeout.idle;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003507 else if (strcmp(args[1], "processing") == 0)
Christopher Fauletf7a30922016-11-10 15:04:51 +01003508 tv = &curagent->timeout.processing;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003509 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003510 ha_alert("parsing [%s:%d] : 'timeout' supports 'hello', 'idle' or 'processing' (got %s).\n",
3511 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003512 err_code |= ERR_ALERT | ERR_FATAL;
3513 goto out;
3514 }
3515 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003516 ha_alert("parsing [%s:%d] : 'timeout %s' expects an integer value (in milliseconds).\n",
3517 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003518 err_code |= ERR_ALERT | ERR_FATAL;
3519 goto out;
3520 }
3521 res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02003522 if (res == PARSE_TIME_OVER) {
3523 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
3524 file, linenum, args[2], args[0], args[1]);
3525 err_code |= ERR_ALERT | ERR_FATAL;
3526 goto out;
3527 }
3528 else if (res == PARSE_TIME_UNDER) {
3529 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
3530 file, linenum, args[2], args[0], args[1]);
3531 err_code |= ERR_ALERT | ERR_FATAL;
3532 goto out;
3533 }
3534 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003535 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'timeout %s'.\n",
3536 file, linenum, *res, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003537 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003538 goto out;
3539 }
3540 *tv = MS_TO_TICKS(timeout);
3541 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003542 else if (strcmp(args[0], "option") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003543 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003544 ha_alert("parsing [%s:%d]: '%s' expects an option name.\n",
3545 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003546 err_code |= ERR_ALERT | ERR_FATAL;
3547 goto out;
3548 }
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003549
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003550 if (strcmp(args[1], "pipelining") == 0) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003551 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003552 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003553 if (kwm == 1)
3554 curagent->flags &= ~SPOE_FL_PIPELINING;
3555 else
3556 curagent->flags |= SPOE_FL_PIPELINING;
3557 goto out;
3558 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003559 else if (strcmp(args[1], "async") == 0) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003560 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003561 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003562 if (kwm == 1)
3563 curagent->flags &= ~SPOE_FL_ASYNC;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003564 else
3565 curagent->flags |= SPOE_FL_ASYNC;
Christopher Faulet305c6072017-02-23 16:17:53 +01003566 goto out;
3567 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003568 else if (strcmp(args[1], "send-frag-payload") == 0) {
Christopher Fauletcecd8522017-02-24 22:11:21 +01003569 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3570 goto out;
3571 if (kwm == 1)
3572 curagent->flags &= ~SPOE_FL_SND_FRAGMENTATION;
3573 else
3574 curagent->flags |= SPOE_FL_SND_FRAGMENTATION;
3575 goto out;
3576 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003577 else if (strcmp(args[1], "dontlog-normal") == 0) {
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003578 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3579 goto out;
3580 if (kwm == 1)
3581 curpxopts2 &= ~PR_O2_NOLOGNORM;
3582 else
3583 curpxopts2 |= PR_O2_NOLOGNORM;
Christopher Faulet799f5182018-04-26 11:36:34 +02003584 goto out;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003585 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003586
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003587 /* Following options does not support negation */
3588 if (kwm == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003589 ha_alert("parsing [%s:%d]: negation is not supported for option '%s'.\n",
3590 file, linenum, args[1]);
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003591 err_code |= ERR_ALERT | ERR_FATAL;
3592 goto out;
3593 }
3594
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003595 if (strcmp(args[1], "var-prefix") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003596 char *tmp;
3597
3598 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003599 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3600 file, linenum, args[0],
3601 args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003602 err_code |= ERR_ALERT | ERR_FATAL;
3603 goto out;
3604 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003605 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3606 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003607 tmp = args[2];
3608 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003609 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003610 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003611 file, linenum, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003612 err_code |= ERR_ALERT | ERR_FATAL;
3613 goto out;
3614 }
3615 tmp++;
3616 }
3617 curagent->var_pfx = strdup(args[2]);
3618 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003619 else if (strcmp(args[1], "force-set-var") == 0) {
Etienne Carriereaec89892017-12-14 09:36:40 +00003620 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3621 goto out;
3622 curagent->flags |= SPOE_FL_FORCE_SET_VAR;
3623 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003624 else if (strcmp(args[1], "continue-on-error") == 0) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003625 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003626 goto out;
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003627 curagent->flags |= SPOE_FL_CONT_ON_ERR;
3628 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003629 else if (strcmp(args[1], "set-on-error") == 0) {
Christopher Faulet985532d2016-11-16 15:36:19 +01003630 char *tmp;
3631
3632 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003633 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3634 file, linenum, args[0],
3635 args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003636 err_code |= ERR_ALERT | ERR_FATAL;
3637 goto out;
3638 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003639 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3640 goto out;
Christopher Faulet985532d2016-11-16 15:36:19 +01003641 tmp = args[2];
3642 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003643 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003644 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003645 file, linenum, args[0], args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003646 err_code |= ERR_ALERT | ERR_FATAL;
3647 goto out;
3648 }
3649 tmp++;
3650 }
3651 curagent->var_on_error = strdup(args[2]);
3652 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003653 else if (strcmp(args[1], "set-process-time") == 0) {
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003654 char *tmp;
3655
3656 if (!*args[2]) {
3657 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3658 file, linenum, args[0],
3659 args[1]);
3660 err_code |= ERR_ALERT | ERR_FATAL;
3661 goto out;
3662 }
3663 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3664 goto out;
3665 tmp = args[2];
3666 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003667 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003668 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003669 file, linenum, args[0], args[1]);
3670 err_code |= ERR_ALERT | ERR_FATAL;
3671 goto out;
3672 }
3673 tmp++;
3674 }
3675 curagent->var_t_process = strdup(args[2]);
3676 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003677 else if (strcmp(args[1], "set-total-time") == 0) {
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003678 char *tmp;
3679
3680 if (!*args[2]) {
3681 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3682 file, linenum, args[0],
3683 args[1]);
3684 err_code |= ERR_ALERT | ERR_FATAL;
3685 goto out;
3686 }
3687 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3688 goto out;
3689 tmp = args[2];
3690 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003691 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003692 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003693 file, linenum, args[0], args[1]);
3694 err_code |= ERR_ALERT | ERR_FATAL;
3695 goto out;
3696 }
3697 tmp++;
3698 }
3699 curagent->var_t_total = strdup(args[2]);
3700 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003701 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003702 ha_alert("parsing [%s:%d]: option '%s' is not supported.\n",
3703 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003704 err_code |= ERR_ALERT | ERR_FATAL;
3705 goto out;
3706 }
Christopher Faulet48026722016-11-16 15:01:12 +01003707 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003708 else if (strcmp(args[0], "maxconnrate") == 0) {
Christopher Faulet48026722016-11-16 15:01:12 +01003709 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003710 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3711 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003712 err_code |= ERR_ALERT | ERR_FATAL;
3713 goto out;
3714 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003715 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003716 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003717 curagent->cps_max = atol(args[1]);
3718 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003719 else if (strcmp(args[0], "maxerrrate") == 0) {
Christopher Faulet48026722016-11-16 15:01:12 +01003720 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003721 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3722 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003723 err_code |= ERR_ALERT | ERR_FATAL;
3724 goto out;
3725 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003726 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003727 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003728 curagent->eps_max = atol(args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003729 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003730 else if (strcmp(args[0], "max-frame-size") == 0) {
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003731 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003732 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3733 file, linenum, args[0]);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003734 err_code |= ERR_ALERT | ERR_FATAL;
3735 goto out;
3736 }
3737 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3738 goto out;
3739 curagent->max_frame_size = atol(args[1]);
3740 if (curagent->max_frame_size < MIN_FRAME_SIZE ||
3741 curagent->max_frame_size > MAX_FRAME_SIZE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003742 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument in the range [%d, %d].\n",
3743 file, linenum, args[0], MIN_FRAME_SIZE, MAX_FRAME_SIZE);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003744 err_code |= ERR_ALERT | ERR_FATAL;
3745 goto out;
3746 }
3747 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003748 else if (strcmp(args[0], "max-waiting-frames") == 0) {
Christopher Faulete8ade382018-01-25 15:32:22 +01003749 if (!*args[1]) {
3750 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3751 file, linenum, args[0]);
3752 err_code |= ERR_ALERT | ERR_FATAL;
3753 goto out;
3754 }
3755 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3756 goto out;
3757 curagent->max_fpa = atol(args[1]);
3758 if (curagent->max_fpa < 1) {
3759 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument.\n",
3760 file, linenum, args[0]);
3761 err_code |= ERR_ALERT | ERR_FATAL;
3762 goto out;
3763 }
3764 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003765 else if (strcmp(args[0], "register-var-names") == 0) {
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003766 int cur_arg;
3767
3768 if (!*args[1]) {
3769 ha_alert("parsing [%s:%d] : '%s' expects one or more variable names.\n",
3770 file, linenum, args[0]);
3771 err_code |= ERR_ALERT | ERR_FATAL;
3772 goto out;
3773 }
3774 cur_arg = 1;
3775 while (*args[cur_arg]) {
3776 struct spoe_var_placeholder *vph;
3777
3778 if ((vph = calloc(1, sizeof(*vph))) == NULL) {
3779 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3780 err_code |= ERR_ALERT | ERR_ABORT;
3781 goto out;
3782 }
3783 if ((vph->name = strdup(args[cur_arg])) == NULL) {
Tim Duesterhusb2986132019-06-23 22:10:13 +02003784 free(vph);
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003785 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3786 err_code |= ERR_ALERT | ERR_ABORT;
3787 goto out;
3788 }
Willy Tarreau2b718102021-04-21 07:32:39 +02003789 LIST_APPEND(&curvars, &vph->list);
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003790 cur_arg++;
3791 }
3792 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003793 else if (strcmp(args[0], "log") == 0) {
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003794 char *errmsg = NULL;
3795
Emeric Brun9533a702021-04-02 10:13:43 +02003796 if (!parse_logsrv(args, &curlogsrvs, (kwm == 1), file, linenum, &errmsg)) {
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003797 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
3798 err_code |= ERR_ALERT | ERR_FATAL;
3799 goto out;
3800 }
3801 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003802 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003803 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-agent section.\n",
3804 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003805 err_code |= ERR_ALERT | ERR_FATAL;
3806 goto out;
3807 }
3808 out:
3809 return err_code;
3810}
Christopher Faulet11610f32017-09-21 10:23:10 +02003811static int
3812cfg_parse_spoe_group(const char *file, int linenum, char **args, int kwm)
3813{
3814 struct spoe_group *grp;
3815 const char *err;
3816 int err_code = 0;
3817
3818 if ((cfg_scope == NULL && curengine != NULL) ||
3819 (cfg_scope != NULL && curengine == NULL) ||
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003820 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope) != 0))
Christopher Faulet11610f32017-09-21 10:23:10 +02003821 goto out;
3822
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003823 if (strcmp(args[0], "spoe-group") == 0) { /* new spoe-group section */
Christopher Faulet11610f32017-09-21 10:23:10 +02003824 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003825 ha_alert("parsing [%s:%d] : missing name for spoe-group section.\n",
3826 file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003827 err_code |= ERR_ALERT | ERR_ABORT;
3828 goto out;
3829 }
3830 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3831 err_code |= ERR_ABORT;
3832 goto out;
3833 }
3834
3835 err = invalid_char(args[1]);
3836 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003837 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3838 file, linenum, *err, args[0], args[1]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003839 err_code |= ERR_ALERT | ERR_ABORT;
3840 goto out;
3841 }
3842
3843 list_for_each_entry(grp, &curgrps, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003844 if (strcmp(grp->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003845 ha_alert("parsing [%s:%d]: spoe-group section '%s' has the same"
3846 " name as another one declared at %s:%d.\n",
3847 file, linenum, args[1], grp->conf.file, grp->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02003848 err_code |= ERR_ALERT | ERR_FATAL;
3849 goto out;
3850 }
3851 }
3852
3853 if ((curgrp = calloc(1, sizeof(*curgrp))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003854 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003855 err_code |= ERR_ALERT | ERR_ABORT;
3856 goto out;
3857 }
3858
3859 curgrp->id = strdup(args[1]);
3860 curgrp->conf.file = strdup(file);
3861 curgrp->conf.line = linenum;
3862 LIST_INIT(&curgrp->phs);
3863 LIST_INIT(&curgrp->messages);
Willy Tarreau2b718102021-04-21 07:32:39 +02003864 LIST_APPEND(&curgrps, &curgrp->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02003865 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003866 else if (strcmp(args[0], "messages") == 0) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003867 int cur_arg = 1;
3868 while (*args[cur_arg]) {
3869 struct spoe_placeholder *ph = NULL;
3870
3871 list_for_each_entry(ph, &curgrp->phs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003872 if (strcmp(ph->id, args[cur_arg]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003873 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3874 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003875 err_code |= ERR_ALERT | ERR_FATAL;
3876 goto out;
3877 }
3878 }
3879
3880 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003881 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003882 err_code |= ERR_ALERT | ERR_ABORT;
3883 goto out;
3884 }
3885 ph->id = strdup(args[cur_arg]);
Willy Tarreau2b718102021-04-21 07:32:39 +02003886 LIST_APPEND(&curgrp->phs, &ph->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02003887 cur_arg++;
3888 }
3889 }
3890 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003891 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-group section.\n",
3892 file, linenum, args[0]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003893 err_code |= ERR_ALERT | ERR_FATAL;
3894 goto out;
3895 }
3896 out:
3897 return err_code;
3898}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003899
3900static int
3901cfg_parse_spoe_message(const char *file, int linenum, char **args, int kwm)
3902{
3903 struct spoe_message *msg;
3904 struct spoe_arg *arg;
3905 const char *err;
3906 char *errmsg = NULL;
3907 int err_code = 0;
3908
3909 if ((cfg_scope == NULL && curengine != NULL) ||
3910 (cfg_scope != NULL && curengine == NULL) ||
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003911 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope) != 0))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003912 goto out;
3913
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003914 if (strcmp(args[0], "spoe-message") == 0) { /* new spoe-message section */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003915 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003916 ha_alert("parsing [%s:%d] : missing name for spoe-message section.\n",
3917 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003918 err_code |= ERR_ALERT | ERR_ABORT;
3919 goto out;
3920 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003921 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3922 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003923 goto out;
3924 }
3925
3926 err = invalid_char(args[1]);
3927 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003928 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3929 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003930 err_code |= ERR_ALERT | ERR_ABORT;
3931 goto out;
3932 }
3933
3934 list_for_each_entry(msg, &curmsgs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003935 if (strcmp(msg->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003936 ha_alert("parsing [%s:%d]: spoe-message section '%s' has the same"
3937 " name as another one declared at %s:%d.\n",
3938 file, linenum, args[1], msg->conf.file, msg->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003939 err_code |= ERR_ALERT | ERR_FATAL;
3940 goto out;
3941 }
3942 }
3943
3944 if ((curmsg = calloc(1, sizeof(*curmsg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003945 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003946 err_code |= ERR_ALERT | ERR_ABORT;
3947 goto out;
3948 }
3949
3950 curmsg->id = strdup(args[1]);
3951 curmsg->id_len = strlen(curmsg->id);
3952 curmsg->event = SPOE_EV_NONE;
3953 curmsg->conf.file = strdup(file);
3954 curmsg->conf.line = linenum;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003955 curmsg->nargs = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003956 LIST_INIT(&curmsg->args);
Christopher Faulet57583e42017-09-04 15:41:09 +02003957 LIST_INIT(&curmsg->acls);
Christopher Faulet11610f32017-09-21 10:23:10 +02003958 LIST_INIT(&curmsg->by_evt);
3959 LIST_INIT(&curmsg->by_grp);
Willy Tarreau2b718102021-04-21 07:32:39 +02003960 LIST_APPEND(&curmsgs, &curmsg->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003961 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003962 else if (strcmp(args[0], "args") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003963 int cur_arg = 1;
3964
3965 curproxy->conf.args.ctx = ARGC_SPOE;
3966 curproxy->conf.args.file = file;
3967 curproxy->conf.args.line = linenum;
3968 while (*args[cur_arg]) {
3969 char *delim = strchr(args[cur_arg], '=');
3970 int idx = 0;
3971
3972 if ((arg = calloc(1, sizeof(*arg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003973 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003974 err_code |= ERR_ALERT | ERR_ABORT;
3975 goto out;
3976 }
3977
3978 if (!delim) {
3979 arg->name = NULL;
3980 arg->name_len = 0;
3981 delim = args[cur_arg];
3982 }
3983 else {
3984 arg->name = my_strndup(args[cur_arg], delim - args[cur_arg]);
3985 arg->name_len = delim - args[cur_arg];
3986 delim++;
3987 }
Christopher Fauletb0b42382017-02-23 22:41:09 +01003988 arg->expr = sample_parse_expr((char*[]){delim, NULL},
3989 &idx, file, linenum, &errmsg,
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01003990 &curproxy->conf.args, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003991 if (arg->expr == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003992 ha_alert("parsing [%s:%d] : '%s': %s.\n", file, linenum, args[0], errmsg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003993 err_code |= ERR_ALERT | ERR_FATAL;
3994 free(arg->name);
3995 free(arg);
3996 goto out;
3997 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003998 curmsg->nargs++;
Willy Tarreau2b718102021-04-21 07:32:39 +02003999 LIST_APPEND(&curmsg->args, &arg->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004000 cur_arg++;
4001 }
4002 curproxy->conf.args.file = NULL;
4003 curproxy->conf.args.line = 0;
4004 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004005 else if (strcmp(args[0], "acl") == 0) {
Christopher Faulet57583e42017-09-04 15:41:09 +02004006 err = invalid_char(args[1]);
4007 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004008 ha_alert("parsing [%s:%d] : character '%c' is not permitted in acl name '%s'.\n",
4009 file, linenum, *err, args[1]);
Christopher Faulet57583e42017-09-04 15:41:09 +02004010 err_code |= ERR_ALERT | ERR_FATAL;
4011 goto out;
4012 }
Tim Duesterhus0cf811a2020-02-05 21:00:50 +01004013 if (strcasecmp(args[1], "or") == 0) {
Tim Duesterhusf1bc24c2020-02-06 22:04:03 +01004014 ha_alert("parsing [%s:%d] : acl name '%s' will never match. 'or' is used to express a "
Tim Duesterhus0cf811a2020-02-05 21:00:50 +01004015 "logical disjunction within a condition.\n",
4016 file, linenum, args[1]);
4017 err_code |= ERR_ALERT | ERR_FATAL;
4018 goto out;
4019 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004020 if (parse_acl((const char **)args + 1, &curmsg->acls, &errmsg, &curproxy->conf.args, file, linenum) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004021 ha_alert("parsing [%s:%d] : error detected while parsing ACL '%s' : %s.\n",
4022 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02004023 err_code |= ERR_ALERT | ERR_FATAL;
4024 goto out;
4025 }
4026 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004027 else if (strcmp(args[0], "event") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004028 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004029 ha_alert("parsing [%s:%d] : missing event name.\n", file, linenum);
Christopher Fauletecc537a2017-02-23 22:52:39 +01004030 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004031 goto out;
4032 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004033 /* if (alertif_too_many_args(1, file, linenum, args, &err_code)) */
4034 /* goto out; */
Christopher Fauletecc537a2017-02-23 22:52:39 +01004035
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004036 if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_CLIENT_SESS]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004037 curmsg->event = SPOE_EV_ON_CLIENT_SESS;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004038 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_SERVER_SESS]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004039 curmsg->event = SPOE_EV_ON_SERVER_SESS;
4040
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004041 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_FE]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004042 curmsg->event = SPOE_EV_ON_TCP_REQ_FE;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004043 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_BE]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004044 curmsg->event = SPOE_EV_ON_TCP_REQ_BE;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004045 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_RSP]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004046 curmsg->event = SPOE_EV_ON_TCP_RSP;
4047
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004048 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_FE]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004049 curmsg->event = SPOE_EV_ON_HTTP_REQ_FE;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004050 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_BE]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004051 curmsg->event = SPOE_EV_ON_HTTP_REQ_BE;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004052 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_RSP]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004053 curmsg->event = SPOE_EV_ON_HTTP_RSP;
4054 else {
Joseph Herlantf1da69d2018-11-15 13:49:02 -08004055 ha_alert("parsing [%s:%d] : unknown event '%s'.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01004056 file, linenum, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01004057 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004058 goto out;
4059 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004060
4061 if (strcmp(args[2], "if") == 0 || strcmp(args[2], "unless") == 0) {
4062 struct acl_cond *cond;
4063
4064 cond = build_acl_cond(file, linenum, &curmsg->acls,
4065 curproxy, (const char **)args+2,
4066 &errmsg);
4067 if (cond == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004068 ha_alert("parsing [%s:%d] : error detected while "
4069 "parsing an 'event %s' condition : %s.\n",
4070 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02004071 err_code |= ERR_ALERT | ERR_FATAL;
4072 goto out;
4073 }
4074 curmsg->cond = cond;
4075 }
4076 else if (*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004077 ha_alert("parsing [%s:%d]: 'event %s' expects either 'if' "
4078 "or 'unless' followed by a condition but found '%s'.\n",
4079 file, linenum, args[1], args[2]);
Christopher Faulet57583e42017-09-04 15:41:09 +02004080 err_code |= ERR_ALERT | ERR_FATAL;
4081 goto out;
4082 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004083 }
4084 else if (!*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004085 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-message section.\n",
4086 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004087 err_code |= ERR_ALERT | ERR_FATAL;
4088 goto out;
4089 }
4090 out:
4091 free(errmsg);
4092 return err_code;
4093}
4094
4095/* Return -1 on error, else 0 */
4096static int
4097parse_spoe_flt(char **args, int *cur_arg, struct proxy *px,
4098 struct flt_conf *fconf, char **err, void *private)
4099{
4100 struct list backup_sections;
4101 struct spoe_config *conf;
4102 struct spoe_message *msg, *msgback;
Christopher Faulet11610f32017-09-21 10:23:10 +02004103 struct spoe_group *grp, *grpback;
4104 struct spoe_placeholder *ph, *phback;
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004105 struct spoe_var_placeholder *vph, *vphback;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004106 struct logsrv *logsrv, *logsrvback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004107 char *file = NULL, *engine = NULL;
4108 int ret, pos = *cur_arg + 1;
4109
Christopher Faulet84c844e2018-03-23 14:37:14 +01004110 LIST_INIT(&curmsgs);
4111 LIST_INIT(&curgrps);
4112 LIST_INIT(&curmphs);
4113 LIST_INIT(&curgphs);
4114 LIST_INIT(&curvars);
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004115 LIST_INIT(&curlogsrvs);
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004116 curpxopts = 0;
4117 curpxopts2 = 0;
Christopher Faulet84c844e2018-03-23 14:37:14 +01004118
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004119 conf = calloc(1, sizeof(*conf));
4120 if (conf == NULL) {
4121 memprintf(err, "%s: out of memory", args[*cur_arg]);
4122 goto error;
4123 }
4124 conf->proxy = px;
4125
4126 while (*args[pos]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004127 if (strcmp(args[pos], "config") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004128 if (!*args[pos+1]) {
4129 memprintf(err, "'%s' : '%s' option without value",
4130 args[*cur_arg], args[pos]);
4131 goto error;
4132 }
4133 file = args[pos+1];
4134 pos += 2;
4135 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004136 else if (strcmp(args[pos], "engine") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004137 if (!*args[pos+1]) {
4138 memprintf(err, "'%s' : '%s' option without value",
4139 args[*cur_arg], args[pos]);
4140 goto error;
4141 }
4142 engine = args[pos+1];
4143 pos += 2;
4144 }
4145 else {
4146 memprintf(err, "unknown keyword '%s'", args[pos]);
4147 goto error;
4148 }
4149 }
4150 if (file == NULL) {
4151 memprintf(err, "'%s' : missing config file", args[*cur_arg]);
4152 goto error;
4153 }
4154
4155 /* backup sections and register SPOE sections */
4156 LIST_INIT(&backup_sections);
4157 cfg_backup_sections(&backup_sections);
Christopher Faulet11610f32017-09-21 10:23:10 +02004158 cfg_register_section("spoe-agent", cfg_parse_spoe_agent, NULL);
4159 cfg_register_section("spoe-group", cfg_parse_spoe_group, NULL);
William Lallemandd2ff56d2017-10-16 11:06:50 +02004160 cfg_register_section("spoe-message", cfg_parse_spoe_message, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004161
4162 /* Parse SPOE filter configuration file */
4163 curengine = engine;
4164 curproxy = px;
4165 curagent = NULL;
4166 curmsg = NULL;
4167 ret = readcfgfile(file);
4168 curproxy = NULL;
4169
4170 /* unregister SPOE sections and restore previous sections */
4171 cfg_unregister_sections();
4172 cfg_restore_sections(&backup_sections);
4173
4174 if (ret == -1) {
4175 memprintf(err, "Could not open configuration file %s : %s",
4176 file, strerror(errno));
4177 goto error;
4178 }
4179 if (ret & (ERR_ABORT|ERR_FATAL)) {
4180 memprintf(err, "Error(s) found in configuration file %s", file);
4181 goto error;
4182 }
4183
4184 /* Check SPOE agent */
4185 if (curagent == NULL) {
4186 memprintf(err, "No SPOE agent found in file %s", file);
4187 goto error;
4188 }
4189 if (curagent->b.name == NULL) {
4190 memprintf(err, "No backend declared for SPOE agent '%s' declared at %s:%d",
4191 curagent->id, curagent->conf.file, curagent->conf.line);
4192 goto error;
4193 }
Christopher Fauletf7a30922016-11-10 15:04:51 +01004194 if (curagent->timeout.hello == TICK_ETERNITY ||
4195 curagent->timeout.idle == TICK_ETERNITY ||
Christopher Fauletf7a30922016-11-10 15:04:51 +01004196 curagent->timeout.processing == TICK_ETERNITY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004197 ha_warning("Proxy '%s': missing timeouts for SPOE agent '%s' declare at %s:%d.\n"
4198 " | While not properly invalid, you will certainly encounter various problems\n"
4199 " | with such a configuration. To fix this, please ensure that all following\n"
4200 " | timeouts are set to a non-zero value: 'hello', 'idle', 'processing'.\n",
4201 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004202 }
4203 if (curagent->var_pfx == NULL) {
4204 char *tmp = curagent->id;
4205
4206 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01004207 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004208 memprintf(err, "Invalid variable prefix '%s' for SPOE agent '%s' declared at %s:%d. "
4209 "Use 'option var-prefix' to set it. Only [a-zA-Z0-9_.] chars are supported.\n",
4210 curagent->id, curagent->id, curagent->conf.file, curagent->conf.line);
4211 goto error;
4212 }
4213 tmp++;
4214 }
4215 curagent->var_pfx = strdup(curagent->id);
4216 }
4217
Christopher Fauletb7426d12018-03-21 14:12:17 +01004218 if (curagent->var_on_error) {
4219 struct arg arg;
4220
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004221 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Fauletb7426d12018-03-21 14:12:17 +01004222 curagent->var_pfx, curagent->var_on_error);
4223
4224 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004225 arg.data.str.area = trash.area;
4226 arg.data.str.data = trash.data;
William Dauchyafb93682021-01-05 11:14:58 +01004227 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_arg() */
Christopher Fauletb7426d12018-03-21 14:12:17 +01004228 if (!vars_check_arg(&arg, err)) {
4229 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4230 curagent->id, curagent->var_pfx, curagent->var_on_error, *err);
4231 goto error;
4232 }
4233 }
4234
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004235 if (curagent->var_t_process) {
4236 struct arg arg;
4237
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004238 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004239 curagent->var_pfx, curagent->var_t_process);
4240
4241 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004242 arg.data.str.area = trash.area;
4243 arg.data.str.data = trash.data;
William Dauchyafb93682021-01-05 11:14:58 +01004244 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_arg() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004245 if (!vars_check_arg(&arg, err)) {
4246 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4247 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4248 goto error;
4249 }
4250 }
4251
4252 if (curagent->var_t_total) {
4253 struct arg arg;
4254
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004255 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004256 curagent->var_pfx, curagent->var_t_total);
4257
4258 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004259 arg.data.str.area = trash.area;
4260 arg.data.str.data = trash.data;
William Dauchyafb93682021-01-05 11:14:58 +01004261 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_arg() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004262 if (!vars_check_arg(&arg, err)) {
4263 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4264 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4265 goto error;
4266 }
4267 }
4268
Christopher Faulet11610f32017-09-21 10:23:10 +02004269 if (LIST_ISEMPTY(&curmphs) && LIST_ISEMPTY(&curgphs)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004270 ha_warning("Proxy '%s': No message/group used by SPOE agent '%s' declared at %s:%d.\n",
4271 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004272 goto finish;
4273 }
4274
Christopher Faulet11610f32017-09-21 10:23:10 +02004275 /* Replace placeholders by the corresponding messages for the SPOE
4276 * agent */
4277 list_for_each_entry(ph, &curmphs, list) {
4278 list_for_each_entry(msg, &curmsgs, list) {
Christopher Fauleta21b0642017-01-09 16:56:23 +01004279 struct spoe_arg *arg;
4280 unsigned int where;
4281
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004282 if (strcmp(msg->id, ph->id) == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004283 if ((px->cap & (PR_CAP_FE|PR_CAP_BE)) == (PR_CAP_FE|PR_CAP_BE)) {
4284 if (msg->event == SPOE_EV_ON_TCP_REQ_BE)
4285 msg->event = SPOE_EV_ON_TCP_REQ_FE;
4286 if (msg->event == SPOE_EV_ON_HTTP_REQ_BE)
4287 msg->event = SPOE_EV_ON_HTTP_REQ_FE;
4288 }
4289 if (!(px->cap & PR_CAP_FE) && (msg->event == SPOE_EV_ON_CLIENT_SESS ||
4290 msg->event == SPOE_EV_ON_TCP_REQ_FE ||
4291 msg->event == SPOE_EV_ON_HTTP_REQ_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004292 ha_warning("Proxy '%s': frontend event used on a backend proxy at %s:%d.\n",
4293 px->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004294 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004295 }
4296 if (msg->event == SPOE_EV_NONE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004297 ha_warning("Proxy '%s': Ignore SPOE message '%s' without event at %s:%d.\n",
4298 px->id, msg->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004299 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004300 }
Christopher Fauleta21b0642017-01-09 16:56:23 +01004301
4302 where = 0;
4303 switch (msg->event) {
4304 case SPOE_EV_ON_CLIENT_SESS:
4305 where |= SMP_VAL_FE_CON_ACC;
4306 break;
4307
4308 case SPOE_EV_ON_TCP_REQ_FE:
4309 where |= SMP_VAL_FE_REQ_CNT;
4310 break;
4311
4312 case SPOE_EV_ON_HTTP_REQ_FE:
4313 where |= SMP_VAL_FE_HRQ_HDR;
4314 break;
4315
4316 case SPOE_EV_ON_TCP_REQ_BE:
4317 if (px->cap & PR_CAP_FE)
4318 where |= SMP_VAL_FE_REQ_CNT;
4319 if (px->cap & PR_CAP_BE)
4320 where |= SMP_VAL_BE_REQ_CNT;
4321 break;
4322
4323 case SPOE_EV_ON_HTTP_REQ_BE:
4324 if (px->cap & PR_CAP_FE)
4325 where |= SMP_VAL_FE_HRQ_HDR;
4326 if (px->cap & PR_CAP_BE)
4327 where |= SMP_VAL_BE_HRQ_HDR;
4328 break;
4329
4330 case SPOE_EV_ON_SERVER_SESS:
4331 where |= SMP_VAL_BE_SRV_CON;
4332 break;
4333
4334 case SPOE_EV_ON_TCP_RSP:
4335 if (px->cap & PR_CAP_FE)
4336 where |= SMP_VAL_FE_RES_CNT;
4337 if (px->cap & PR_CAP_BE)
4338 where |= SMP_VAL_BE_RES_CNT;
4339 break;
4340
4341 case SPOE_EV_ON_HTTP_RSP:
4342 if (px->cap & PR_CAP_FE)
4343 where |= SMP_VAL_FE_HRS_HDR;
4344 if (px->cap & PR_CAP_BE)
4345 where |= SMP_VAL_BE_HRS_HDR;
4346 break;
4347
4348 default:
4349 break;
4350 }
4351
4352 list_for_each_entry(arg, &msg->args, list) {
4353 if (!(arg->expr->fetch->val & where)) {
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004354 memprintf(err, "Ignore SPOE message '%s' at %s:%d: "
Christopher Fauleta21b0642017-01-09 16:56:23 +01004355 "some args extract information from '%s', "
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004356 "none of which is available here ('%s')",
4357 msg->id, msg->conf.file, msg->conf.line,
Christopher Fauleta21b0642017-01-09 16:56:23 +01004358 sample_ckp_names(arg->expr->fetch->use),
4359 sample_ckp_names(where));
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004360 goto error;
Christopher Fauleta21b0642017-01-09 16:56:23 +01004361 }
4362 }
4363
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004364 msg->agent = curagent;
Willy Tarreau2b718102021-04-21 07:32:39 +02004365 LIST_APPEND(&curagent->events[msg->event], &msg->by_evt);
Christopher Faulet11610f32017-09-21 10:23:10 +02004366 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004367 }
4368 }
4369 memprintf(err, "SPOE agent '%s' try to use undefined SPOE message '%s' at %s:%d",
Christopher Faulet11610f32017-09-21 10:23:10 +02004370 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004371 goto error;
Christopher Faulet11610f32017-09-21 10:23:10 +02004372 next_mph:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004373 continue;
4374 }
4375
Christopher Faulet11610f32017-09-21 10:23:10 +02004376 /* Replace placeholders by the corresponding groups for the SPOE
4377 * agent */
4378 list_for_each_entry(ph, &curgphs, list) {
4379 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004380 if (strcmp(grp->id, ph->id) == 0) {
Christopher Faulet11610f32017-09-21 10:23:10 +02004381 grp->agent = curagent;
Willy Tarreau2b718102021-04-21 07:32:39 +02004382 LIST_DELETE(&grp->list);
4383 LIST_APPEND(&curagent->groups, &grp->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02004384 goto next_aph;
4385 }
4386 }
4387 memprintf(err, "SPOE agent '%s' try to use undefined SPOE group '%s' at %s:%d",
4388 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
4389 goto error;
4390 next_aph:
4391 continue;
4392 }
4393
4394 /* Replace placeholders by the corresponding message for each SPOE
4395 * group of the SPOE agent */
4396 list_for_each_entry(grp, &curagent->groups, list) {
4397 list_for_each_entry_safe(ph, phback, &grp->phs, list) {
4398 list_for_each_entry(msg, &curmsgs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004399 if (strcmp(msg->id, ph->id) == 0) {
Christopher Faulet11610f32017-09-21 10:23:10 +02004400 if (msg->group != NULL) {
4401 memprintf(err, "SPOE message '%s' already belongs to "
4402 "the SPOE group '%s' declare at %s:%d",
4403 msg->id, msg->group->id,
4404 msg->group->conf.file,
4405 msg->group->conf.line);
4406 goto error;
4407 }
4408
4409 /* Scope for arguments are not checked for now. We will check
4410 * them only if a rule use the corresponding SPOE group. */
4411 msg->agent = curagent;
4412 msg->group = grp;
Willy Tarreau2b718102021-04-21 07:32:39 +02004413 LIST_DELETE(&ph->list);
4414 LIST_APPEND(&grp->messages, &msg->by_grp);
Christopher Faulet11610f32017-09-21 10:23:10 +02004415 goto next_mph_grp;
4416 }
4417 }
4418 memprintf(err, "SPOE group '%s' try to use undefined SPOE message '%s' at %s:%d",
4419 grp->id, ph->id, curagent->conf.file, curagent->conf.line);
4420 goto error;
4421 next_mph_grp:
4422 continue;
4423 }
4424 }
4425
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004426 finish:
Christopher Faulet11610f32017-09-21 10:23:10 +02004427 /* move curmsgs to the agent message list */
4428 curmsgs.n->p = &curagent->messages;
4429 curmsgs.p->n = &curagent->messages;
4430 curagent->messages = curmsgs;
4431 LIST_INIT(&curmsgs);
4432
Christopher Faulet7ee86672017-09-19 11:08:28 +02004433 conf->id = strdup(engine ? engine : curagent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004434 conf->agent = curagent;
Christopher Faulet434b8522021-08-02 17:51:01 +02004435 curagent->spoe_conf = conf;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004436
4437 /* Start agent's proxy initialization here. It will be finished during
4438 * the filter init. */
4439 memset(&conf->agent_fe, 0, sizeof(conf->agent_fe));
4440 init_new_proxy(&conf->agent_fe);
4441 conf->agent_fe.id = conf->agent->id;
4442 conf->agent_fe.parent = conf->agent;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004443 conf->agent_fe.options |= curpxopts;
4444 conf->agent_fe.options2 |= curpxopts2;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004445
4446 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004447 LIST_DELETE(&logsrv->list);
4448 LIST_APPEND(&conf->agent_fe.logsrvs, &logsrv->list);
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004449 }
4450
Christopher Faulet11610f32017-09-21 10:23:10 +02004451 list_for_each_entry_safe(ph, phback, &curmphs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004452 LIST_DELETE(&ph->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02004453 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004454 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004455 list_for_each_entry_safe(ph, phback, &curgphs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004456 LIST_DELETE(&ph->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02004457 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004458 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004459 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4460 struct arg arg;
4461
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004462 trash.data = snprintf(trash.area, trash.size, "proc.%s.%s",
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004463 curagent->var_pfx, vph->name);
4464
4465 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004466 arg.data.str.area = trash.area;
4467 arg.data.str.data = trash.data;
William Dauchyafb93682021-01-05 11:14:58 +01004468 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_arg() */
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004469 if (!vars_check_arg(&arg, err)) {
4470 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4471 curagent->id, curagent->var_pfx, vph->name, *err);
4472 goto error;
4473 }
4474
Willy Tarreau2b718102021-04-21 07:32:39 +02004475 LIST_DELETE(&vph->list);
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004476 free(vph->name);
4477 free(vph);
4478 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004479 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004480 LIST_DELETE(&grp->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02004481 spoe_release_group(grp);
4482 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004483 *cur_arg = pos;
Christopher Faulet3b386a32017-02-23 10:17:15 +01004484 fconf->id = spoe_filter_id;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004485 fconf->ops = &spoe_ops;
4486 fconf->conf = conf;
4487 return 0;
4488
4489 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01004490 spoe_release_agent(curagent);
Christopher Faulet11610f32017-09-21 10:23:10 +02004491 list_for_each_entry_safe(ph, phback, &curmphs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004492 LIST_DELETE(&ph->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02004493 spoe_release_placeholder(ph);
4494 }
4495 list_for_each_entry_safe(ph, phback, &curgphs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004496 LIST_DELETE(&ph->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02004497 spoe_release_placeholder(ph);
4498 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004499 list_for_each_entry_safe(vph, vphback, &curvars, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004500 LIST_DELETE(&vph->list);
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004501 free(vph->name);
4502 free(vph);
4503 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004504 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004505 LIST_DELETE(&grp->list);
Christopher Faulet11610f32017-09-21 10:23:10 +02004506 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004507 }
4508 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004509 LIST_DELETE(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01004510 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004511 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004512 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004513 LIST_DELETE(&logsrv->list);
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004514 free(logsrv);
4515 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004516 free(conf);
4517 return -1;
4518}
4519
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004520/* Send message of a SPOE group. This is the action_ptr callback of a rule
4521 * associated to a "send-spoe-group" action.
4522 *
Christopher Faulet13403762019-12-13 09:01:57 +01004523 * It returns ACT_RET_CONT if processing is finished (with error or not), it returns
4524 * ACT_RET_YIELD if the action is in progress. */
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004525static enum act_return
4526spoe_send_group(struct act_rule *rule, struct proxy *px,
4527 struct session *sess, struct stream *s, int flags)
4528{
4529 struct filter *filter;
4530 struct spoe_agent *agent = NULL;
4531 struct spoe_group *group = NULL;
4532 struct spoe_context *ctx = NULL;
4533 int ret, dir;
4534
4535 list_for_each_entry(filter, &s->strm_flt.filters, list) {
4536 if (filter->config == rule->arg.act.p[0]) {
4537 agent = rule->arg.act.p[2];
4538 group = rule->arg.act.p[3];
4539 ctx = filter->ctx;
4540 break;
4541 }
4542 }
4543 if (agent == NULL || group == NULL || ctx == NULL)
Christopher Faulet13403762019-12-13 09:01:57 +01004544 return ACT_RET_CONT;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004545 if (ctx->state == SPOE_CTX_ST_NONE)
4546 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004547
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004548 switch (rule->from) {
4549 case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break;
4550 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
4551 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
4552 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
4553 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
4554 default:
4555 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4556 " - internal error while execute spoe-send-group\n",
4557 (int)now.tv_sec, (int)now.tv_usec, agent->id,
4558 __FUNCTION__, s);
4559 send_log(px, LOG_ERR, "SPOE: [%s] internal error while execute spoe-send-group\n",
4560 agent->id);
4561 return ACT_RET_CONT;
4562 }
4563
4564 ret = spoe_process_group(s, ctx, group, dir);
4565 if (ret == 1)
4566 return ACT_RET_CONT;
4567 else if (ret == 0) {
Christopher Faulet105ba6c2019-12-18 14:41:51 +01004568 if (flags & ACT_OPT_FINAL) {
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004569 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4570 " - failed to process group '%s': interrupted by caller\n",
4571 (int)now.tv_sec, (int)now.tv_usec,
4572 agent->id, __FUNCTION__, s, group->id);
4573 ctx->status_code = SPOE_CTX_ERR_INTERRUPT;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01004574 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02004575 spoe_handle_processing_error(s, agent, ctx, dir);
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004576 return ACT_RET_CONT;
4577 }
4578 return ACT_RET_YIELD;
4579 }
4580 else
Christopher Faulet13403762019-12-13 09:01:57 +01004581 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004582}
4583
4584/* Check an "send-spoe-group" action. Here, we'll try to find the real SPOE
4585 * group associated to <rule>. The format of an rule using 'send-spoe-group'
4586 * action should be:
4587 *
4588 * (http|tcp)-(request|response) send-spoe-group <engine-id> <group-id>
4589 *
4590 * So, we'll loop on each configured SPOE filter for the proxy <px> to find the
4591 * SPOE engine matching <engine-id>. And then, we'll try to find the good group
4592 * matching <group-id>. Finally, we'll check all messages referenced by the SPOE
4593 * group.
4594 *
4595 * The function returns 1 in success case, otherwise, it returns 0 and err is
4596 * filled.
4597 */
4598static int
4599check_send_spoe_group(struct act_rule *rule, struct proxy *px, char **err)
4600{
4601 struct flt_conf *fconf;
4602 struct spoe_config *conf;
4603 struct spoe_agent *agent = NULL;
4604 struct spoe_group *group;
4605 struct spoe_message *msg;
4606 char *engine_id = rule->arg.act.p[0];
4607 char *group_id = rule->arg.act.p[1];
4608 unsigned int where = 0;
4609
4610 switch (rule->from) {
4611 case ACT_F_TCP_REQ_SES: where = SMP_VAL_FE_SES_ACC; break;
4612 case ACT_F_TCP_REQ_CNT: where = SMP_VAL_FE_REQ_CNT; break;
4613 case ACT_F_TCP_RES_CNT: where = SMP_VAL_BE_RES_CNT; break;
4614 case ACT_F_HTTP_REQ: where = SMP_VAL_FE_HRQ_HDR; break;
4615 case ACT_F_HTTP_RES: where = SMP_VAL_BE_HRS_HDR; break;
4616 default:
4617 memprintf(err,
4618 "internal error, unexpected rule->from=%d, please report this bug!",
4619 rule->from);
4620 goto error;
4621 }
4622
4623 /* Try to find the SPOE engine by checking all SPOE filters for proxy
4624 * <px> */
4625 list_for_each_entry(fconf, &px->filter_configs, list) {
4626 conf = fconf->conf;
4627
4628 /* This is not an SPOE filter */
4629 if (fconf->id != spoe_filter_id)
4630 continue;
4631
4632 /* This is the good engine */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004633 if (strcmp(conf->id, engine_id) == 0) {
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004634 agent = conf->agent;
4635 break;
4636 }
4637 }
4638 if (agent == NULL) {
4639 memprintf(err, "unable to find SPOE engine '%s' used by the send-spoe-group '%s'",
4640 engine_id, group_id);
4641 goto error;
4642 }
4643
4644 /* Try to find the right group */
4645 list_for_each_entry(group, &agent->groups, list) {
4646 /* This is the good group */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004647 if (strcmp(group->id, group_id) == 0)
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004648 break;
4649 }
4650 if (&group->list == &agent->groups) {
4651 memprintf(err, "unable to find SPOE group '%s' into SPOE engine '%s' configuration",
4652 group_id, engine_id);
4653 goto error;
4654 }
4655
4656 /* Ok, we found the group, we need to check messages and their
4657 * arguments */
4658 list_for_each_entry(msg, &group->messages, by_grp) {
4659 struct spoe_arg *arg;
4660
4661 list_for_each_entry(arg, &msg->args, list) {
4662 if (!(arg->expr->fetch->val & where)) {
4663 memprintf(err, "Invalid SPOE message '%s' used by SPOE group '%s' at %s:%d: "
4664 "some args extract information from '%s',"
4665 "none of which is available here ('%s')",
4666 msg->id, group->id, msg->conf.file, msg->conf.line,
4667 sample_ckp_names(arg->expr->fetch->use),
4668 sample_ckp_names(where));
4669 goto error;
4670 }
4671 }
4672 }
4673
4674 free(engine_id);
4675 free(group_id);
4676 rule->arg.act.p[0] = fconf; /* Associate filter config with the rule */
4677 rule->arg.act.p[1] = conf; /* Associate SPOE config with the rule */
4678 rule->arg.act.p[2] = agent; /* Associate SPOE agent with the rule */
4679 rule->arg.act.p[3] = group; /* Associate SPOE group with the rule */
4680 return 1;
4681
4682 error:
4683 free(engine_id);
4684 free(group_id);
4685 return 0;
4686}
4687
4688/* Parse 'send-spoe-group' action following the format:
4689 *
4690 * ... send-spoe-group <engine-id> <group-id>
4691 *
4692 * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error
4693 * message. Otherwise, it returns ACT_RET_PRS_OK and parsing engine and group
4694 * ids are saved and used later, when the rule will be checked.
4695 */
4696static enum act_parse_ret
4697parse_send_spoe_group(const char **args, int *orig_arg, struct proxy *px,
4698 struct act_rule *rule, char **err)
4699{
4700 if (!*args[*orig_arg] || !*args[*orig_arg+1] ||
4701 (*args[*orig_arg+2] && strcmp(args[*orig_arg+2], "if") != 0 && strcmp(args[*orig_arg+2], "unless") != 0)) {
4702 memprintf(err, "expects 2 arguments: <engine-id> <group-id>");
4703 return ACT_RET_PRS_ERR;
4704 }
4705 rule->arg.act.p[0] = strdup(args[*orig_arg]); /* Copy the SPOE engine id */
4706 rule->arg.act.p[1] = strdup(args[*orig_arg+1]); /* Cope the SPOE group id */
4707
4708 (*orig_arg) += 2;
4709
4710 rule->action = ACT_CUSTOM;
4711 rule->action_ptr = spoe_send_group;
4712 rule->check_ptr = check_send_spoe_group;
4713 return ACT_RET_PRS_OK;
4714}
4715
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004716
4717/* Declare the filter parser for "spoe" keyword */
4718static struct flt_kw_list flt_kws = { "SPOE", { }, {
4719 { "spoe", parse_spoe_flt, NULL },
4720 { NULL, NULL, NULL },
4721 }
4722};
4723
Willy Tarreau0108d902018-11-25 19:14:37 +01004724INITCALL1(STG_REGISTER, flt_register_keywords, &flt_kws);
4725
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004726/* Delcate the action parser for "spoe-action" keyword */
4727static struct action_kw_list tcp_req_action_kws = { { }, {
4728 { "send-spoe-group", parse_send_spoe_group },
4729 { /* END */ },
4730 }
4731};
Willy Tarreau0108d902018-11-25 19:14:37 +01004732
4733INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_action_kws);
4734
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004735static struct action_kw_list tcp_res_action_kws = { { }, {
4736 { "send-spoe-group", parse_send_spoe_group },
4737 { /* END */ },
4738 }
4739};
Willy Tarreau0108d902018-11-25 19:14:37 +01004740
4741INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_action_kws);
4742
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004743static struct action_kw_list http_req_action_kws = { { }, {
4744 { "send-spoe-group", parse_send_spoe_group },
4745 { /* END */ },
4746 }
4747};
Willy Tarreau0108d902018-11-25 19:14:37 +01004748
4749INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_action_kws);
4750
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004751static struct action_kw_list http_res_action_kws = { { }, {
4752 { "send-spoe-group", parse_send_spoe_group },
4753 { /* END */ },
4754 }
4755};
4756
Willy Tarreau0108d902018-11-25 19:14:37 +01004757INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_action_kws);