blob: 83f6074f4def0b2ae00b5cab4b95a2bd0c7dbdd2 [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>
Willy Tarreauc7babd82020-06-04 21:29:29 +020020#include <haproxy/filters.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020021#include <haproxy/freq_ctr.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020022#include <haproxy/frontend.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020023#include <haproxy/global.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020024#include <haproxy/http_rules.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020025#include <haproxy/log.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020026#include <haproxy/pool.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020027#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020028#include <haproxy/sample.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020029#include <haproxy/session.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020030#include <haproxy/signal.h>
Christopher Faulet1d7d0f82021-02-19 10:56:41 +010031#include <haproxy/sink.h>
Willy Tarreau6c58ab02020-06-04 22:35:49 +020032#include <haproxy/spoe.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020033#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020034#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020035#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020036#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020037#include <haproxy/thread.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020038#include <haproxy/time.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020039#include <haproxy/vars.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020040
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020041
42#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
43#define SPOE_PRINTF(x...) fprintf(x)
Christopher Fauletb077cdc2018-01-24 16:37:57 +010044#define SPOE_DEBUG_STMT(statement) statement
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020045#else
46#define SPOE_PRINTF(x...)
Christopher Fauletb077cdc2018-01-24 16:37:57 +010047#define SPOE_DEBUG_STMT(statement)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020048#endif
49
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +010050/* Reserved 4 bytes to the frame size. So a frame and its size can be written
51 * together in a buffer */
52#define MAX_FRAME_SIZE global.tune.bufsize - 4
53
54/* The minimum size for a frame */
55#define MIN_FRAME_SIZE 256
56
Christopher Fauletf51f5fa2017-01-19 10:01:12 +010057/* Reserved for the metadata and the frame type.
58 * So <MAX_FRAME_SIZE> - <FRAME_HDR_SIZE> is the maximum payload size */
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +010059#define FRAME_HDR_SIZE 32
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020060
Christopher Fauletf51f5fa2017-01-19 10:01:12 +010061/* Helper to get SPOE ctx inside an appctx */
Christopher Faulet42bfa462017-01-04 14:14:19 +010062#define SPOE_APPCTX(appctx) ((struct spoe_appctx *)((appctx)->ctx.spoe.ptr))
63
Christopher Faulet3b386a32017-02-23 10:17:15 +010064/* SPOE filter id. Used to identify SPOE filters */
65const char *spoe_filter_id = "SPOE filter";
66
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020067/* Set if the handle on SIGUSR1 is registered */
68static int sighandler_registered = 0;
69
70/* proxy used during the parsing */
71struct proxy *curproxy = NULL;
72
73/* The name of the SPOE engine, used during the parsing */
74char *curengine = NULL;
75
76/* SPOE agent used during the parsing */
Christopher Faulet11610f32017-09-21 10:23:10 +020077/* SPOE agent/group/message used during the parsing */
78struct spoe_agent *curagent = NULL;
79struct spoe_group *curgrp = NULL;
80struct spoe_message *curmsg = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020081
82/* list of SPOE messages and placeholders used during the parsing */
83struct list curmsgs;
Christopher Faulet11610f32017-09-21 10:23:10 +020084struct list curgrps;
85struct list curmphs;
86struct list curgphs;
Christopher Faulet336d3ef2017-12-22 10:00:55 +010087struct list curvars;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020088
Christopher Faulet7250b8f2018-03-26 17:19:01 +020089/* list of log servers used during the parsing */
90struct list curlogsrvs;
91
Christopher Faulet0e0f0852018-03-26 17:20:36 +020092/* agent's proxy flags (PR_O_* and PR_O2_*) used during parsing */
93int curpxopts;
94int curpxopts2;
95
Christopher Faulet42bfa462017-01-04 14:14:19 +010096/* Pools used to allocate SPOE structs */
Willy Tarreau8ceae722018-11-26 11:58:30 +010097DECLARE_STATIC_POOL(pool_head_spoe_ctx, "spoe_ctx", sizeof(struct spoe_context));
98DECLARE_STATIC_POOL(pool_head_spoe_appctx, "spoe_appctx", sizeof(struct spoe_appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020099
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200100struct flt_ops spoe_ops;
101
Christopher Faulet8ef75252017-02-20 22:56:03 +0100102static int spoe_queue_context(struct spoe_context *ctx);
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200103static int spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait);
104static void spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200105
106/********************************************************************
107 * helper functions/globals
108 ********************************************************************/
109static void
Christopher Faulet11610f32017-09-21 10:23:10 +0200110spoe_release_placeholder(struct spoe_placeholder *ph)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200111{
Christopher Faulet11610f32017-09-21 10:23:10 +0200112 if (!ph)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200113 return;
Christopher Faulet11610f32017-09-21 10:23:10 +0200114 free(ph->id);
115 free(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200116}
117
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200118static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100119spoe_release_message(struct spoe_message *msg)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200120{
Christopher Faulet57583e42017-09-04 15:41:09 +0200121 struct spoe_arg *arg, *argback;
122 struct acl *acl, *aclback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200123
124 if (!msg)
125 return;
126 free(msg->id);
127 free(msg->conf.file);
Christopher Faulet57583e42017-09-04 15:41:09 +0200128 list_for_each_entry_safe(arg, argback, &msg->args, list) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200129 release_sample_expr(arg->expr);
130 free(arg->name);
131 LIST_DEL(&arg->list);
132 free(arg);
133 }
Christopher Faulet57583e42017-09-04 15:41:09 +0200134 list_for_each_entry_safe(acl, aclback, &msg->acls, list) {
135 LIST_DEL(&acl->list);
136 prune_acl(acl);
137 free(acl);
138 }
139 if (msg->cond) {
140 prune_acl_cond(msg->cond);
141 free(msg->cond);
142 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200143 free(msg);
144}
145
146static void
Christopher Faulet11610f32017-09-21 10:23:10 +0200147spoe_release_group(struct spoe_group *grp)
148{
149 if (!grp)
150 return;
151 free(grp->id);
152 free(grp->conf.file);
153 free(grp);
154}
155
156static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100157spoe_release_agent(struct spoe_agent *agent)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200158{
Christopher Faulet11610f32017-09-21 10:23:10 +0200159 struct spoe_message *msg, *msgback;
160 struct spoe_group *grp, *grpback;
Christopher Faulet24289f22017-09-25 14:48:02 +0200161 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200162
163 if (!agent)
164 return;
165 free(agent->id);
166 free(agent->conf.file);
167 free(agent->var_pfx);
Christopher Faulet985532d2016-11-16 15:36:19 +0100168 free(agent->var_on_error);
Christopher Faulet36bda1c2018-03-22 09:08:20 +0100169 free(agent->var_t_process);
170 free(agent->var_t_total);
Christopher Faulet11610f32017-09-21 10:23:10 +0200171 list_for_each_entry_safe(msg, msgback, &agent->messages, list) {
172 LIST_DEL(&msg->list);
173 spoe_release_message(msg);
174 }
175 list_for_each_entry_safe(grp, grpback, &agent->groups, list) {
176 LIST_DEL(&grp->list);
177 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200178 }
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100179 if (agent->rt) {
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200180 for (i = 0; i < global.nbthread; ++i) {
181 free(agent->rt[i].engine_id);
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100182 HA_SPIN_DESTROY(&agent->rt[i].lock);
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200183 }
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100184 }
Christopher Faulet24289f22017-09-25 14:48:02 +0200185 free(agent->rt);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200186 free(agent);
187}
188
189static const char *spoe_frm_err_reasons[SPOE_FRM_ERRS] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100190 [SPOE_FRM_ERR_NONE] = "normal",
191 [SPOE_FRM_ERR_IO] = "I/O error",
192 [SPOE_FRM_ERR_TOUT] = "a timeout occurred",
193 [SPOE_FRM_ERR_TOO_BIG] = "frame is too big",
194 [SPOE_FRM_ERR_INVALID] = "invalid frame received",
195 [SPOE_FRM_ERR_NO_VSN] = "version value not found",
196 [SPOE_FRM_ERR_NO_FRAME_SIZE] = "max-frame-size value not found",
197 [SPOE_FRM_ERR_NO_CAP] = "capabilities value not found",
198 [SPOE_FRM_ERR_BAD_VSN] = "unsupported version",
199 [SPOE_FRM_ERR_BAD_FRAME_SIZE] = "max-frame-size too big or too small",
200 [SPOE_FRM_ERR_FRAG_NOT_SUPPORTED] = "fragmentation not supported",
201 [SPOE_FRM_ERR_INTERLACED_FRAMES] = "invalid interlaced frames",
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100202 [SPOE_FRM_ERR_FRAMEID_NOTFOUND] = "frame-id not found",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100203 [SPOE_FRM_ERR_RES] = "resource allocation error",
204 [SPOE_FRM_ERR_UNKNOWN] = "an unknown error occurred",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200205};
206
207static const char *spoe_event_str[SPOE_EV_EVENTS] = {
208 [SPOE_EV_ON_CLIENT_SESS] = "on-client-session",
209 [SPOE_EV_ON_TCP_REQ_FE] = "on-frontend-tcp-request",
210 [SPOE_EV_ON_TCP_REQ_BE] = "on-backend-tcp-request",
211 [SPOE_EV_ON_HTTP_REQ_FE] = "on-frontend-http-request",
212 [SPOE_EV_ON_HTTP_REQ_BE] = "on-backend-http-request",
213
214 [SPOE_EV_ON_SERVER_SESS] = "on-server-session",
215 [SPOE_EV_ON_TCP_RSP] = "on-tcp-response",
216 [SPOE_EV_ON_HTTP_RSP] = "on-http-response",
217};
218
219
220#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
221
222static const char *spoe_ctx_state_str[SPOE_CTX_ST_ERROR+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100223 [SPOE_CTX_ST_NONE] = "NONE",
224 [SPOE_CTX_ST_READY] = "READY",
225 [SPOE_CTX_ST_ENCODING_MSGS] = "ENCODING_MSGS",
226 [SPOE_CTX_ST_SENDING_MSGS] = "SENDING_MSGS",
227 [SPOE_CTX_ST_WAITING_ACK] = "WAITING_ACK",
228 [SPOE_CTX_ST_DONE] = "DONE",
229 [SPOE_CTX_ST_ERROR] = "ERROR",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200230};
231
232static const char *spoe_appctx_state_str[SPOE_APPCTX_ST_END+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100233 [SPOE_APPCTX_ST_CONNECT] = "CONNECT",
234 [SPOE_APPCTX_ST_CONNECTING] = "CONNECTING",
235 [SPOE_APPCTX_ST_IDLE] = "IDLE",
236 [SPOE_APPCTX_ST_PROCESSING] = "PROCESSING",
237 [SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY] = "SENDING_FRAG_NOTIFY",
238 [SPOE_APPCTX_ST_WAITING_SYNC_ACK] = "WAITING_SYNC_ACK",
239 [SPOE_APPCTX_ST_DISCONNECT] = "DISCONNECT",
240 [SPOE_APPCTX_ST_DISCONNECTING] = "DISCONNECTING",
241 [SPOE_APPCTX_ST_EXIT] = "EXIT",
242 [SPOE_APPCTX_ST_END] = "END",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200243};
244
245#endif
Christopher Fauleta1cda022016-12-21 08:58:06 +0100246
Christopher Faulet8ef75252017-02-20 22:56:03 +0100247/* Used to generates a unique id for an engine. On success, it returns a
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500248 * allocated string. So it is the caller's responsibility to release it. If the
Christopher Faulet8ef75252017-02-20 22:56:03 +0100249 * allocation failed, it returns NULL. */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100250static char *
251generate_pseudo_uuid()
252{
Willy Tarreauee3bcdd2020-03-08 17:48:17 +0100253 ha_generate_uuid(&trash);
Kevin Zhu079f8082020-03-13 10:39:51 +0800254 return my_strndup(trash.area, trash.data);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100255}
256
Christopher Fauletb2dd1e02018-03-22 09:07:41 +0100257
258static inline void
259spoe_update_stat_time(struct timeval *tv, long *t)
260{
261 if (*t == -1)
262 *t = tv_ms_elapsed(tv, &now);
263 else
264 *t += tv_ms_elapsed(tv, &now);
265 tv_zero(tv);
266}
267
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200268/********************************************************************
269 * Functions that encode/decode SPOE frames
270 ********************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200271/* Helper to get static string length, excluding the terminating null byte */
272#define SLEN(str) (sizeof(str)-1)
273
274/* Predefined key used in HELLO/DISCONNECT frames */
275#define SUPPORTED_VERSIONS_KEY "supported-versions"
276#define VERSION_KEY "version"
277#define MAX_FRAME_SIZE_KEY "max-frame-size"
278#define CAPABILITIES_KEY "capabilities"
Christopher Fauleta1cda022016-12-21 08:58:06 +0100279#define ENGINE_ID_KEY "engine-id"
Christopher Fauletba7bc162016-11-07 21:07:38 +0100280#define HEALTHCHECK_KEY "healthcheck"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200281#define STATUS_CODE_KEY "status-code"
282#define MSG_KEY "message"
283
284struct spoe_version {
285 char *str;
286 int min;
287 int max;
288};
289
290/* All supported versions */
291static struct spoe_version supported_versions[] = {
Christopher Faulet63816502018-05-31 14:56:42 +0200292 /* 1.0 is now unsupported because of a bug about frame's flags*/
293 {"2.0", 2000, 2000},
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200294 {NULL, 0, 0}
295};
296
297/* Comma-separated list of supported versions */
Christopher Faulet63816502018-05-31 14:56:42 +0200298#define SUPPORTED_VERSIONS_VAL "2.0"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200299
Christopher Faulet8ef75252017-02-20 22:56:03 +0100300/* Convert a string to a SPOE version value. The string must follow the format
301 * "MAJOR.MINOR". It will be concerted into the integer (1000 * MAJOR + MINOR).
302 * If an error occurred, -1 is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200303static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100304spoe_str_to_vsn(const char *str, size_t len)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200305{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100306 const char *p, *end;
307 int maj, min, vsn;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200308
Christopher Faulet8ef75252017-02-20 22:56:03 +0100309 p = str;
310 end = str+len;
311 maj = min = 0;
312 vsn = -1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200313
Christopher Faulet8ef75252017-02-20 22:56:03 +0100314 /* skip leading spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100315 while (p < end && isspace((unsigned char)*p))
Christopher Faulet8ef75252017-02-20 22:56:03 +0100316 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200317
Christopher Faulet8ef75252017-02-20 22:56:03 +0100318 /* parse Major number, until the '.' */
319 while (*p != '.') {
320 if (p >= end || *p < '0' || *p > '9')
321 goto out;
322 maj *= 10;
323 maj += (*p - '0');
324 p++;
325 }
326
327 /* check Major version */
328 if (!maj)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200329 goto out;
330
Christopher Faulet8ef75252017-02-20 22:56:03 +0100331 p++; /* skip the '.' */
332 if (p >= end || *p < '0' || *p > '9') /* Minor number is missing */
333 goto out;
334
335 /* Parse Minor number */
336 while (p < end) {
337 if (*p < '0' || *p > '9')
338 break;
339 min *= 10;
340 min += (*p - '0');
341 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200342 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100343
344 /* check Minor number */
345 if (min > 999)
346 goto out;
347
348 /* skip trailing spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100349 while (p < end && isspace((unsigned char)*p))
Christopher Faulet8ef75252017-02-20 22:56:03 +0100350 p++;
351 if (p != end)
352 goto out;
353
354 vsn = maj * 1000 + min;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200355 out:
356 return vsn;
357}
358
Christopher Faulet8ef75252017-02-20 22:56:03 +0100359/* Encode the HELLO frame sent by HAProxy to an agent. It returns the number of
Joseph Herlantf7f60312018-11-15 13:46:49 -0800360 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
Christopher Faulet8ef75252017-02-20 22:56:03 +0100361 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200362static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100363spoe_prepare_hahello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200364{
Willy Tarreau83061a82018-07-13 11:56:34 +0200365 struct buffer *chk;
Christopher Faulet42bfa462017-01-04 14:14:19 +0100366 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100367 char *p, *end;
368 unsigned int flags = SPOE_FRM_FL_FIN;
369 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200370
Christopher Faulet8ef75252017-02-20 22:56:03 +0100371 p = frame;
372 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200373
Christopher Faulet8ef75252017-02-20 22:56:03 +0100374 /* Set Frame type */
375 *p++ = SPOE_FRM_T_HAPROXY_HELLO;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200376
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100377 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200378 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100379 memcpy(p, (char *)&flags, 4);
380 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200381
382 /* No stream-id and frame-id for HELLO frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100383 *p++ = 0; *p++ = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200384
385 /* There are 3 mandatory items: "supported-versions", "max-frame-size"
386 * and "capabilities" */
387
388 /* "supported-versions" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100389 sz = SLEN(SUPPORTED_VERSIONS_KEY);
390 if (spoe_encode_buffer(SUPPORTED_VERSIONS_KEY, sz, &p, end) == -1)
391 goto too_big;
392
393 *p++ = SPOE_DATA_T_STR;
394 sz = SLEN(SUPPORTED_VERSIONS_VAL);
395 if (spoe_encode_buffer(SUPPORTED_VERSIONS_VAL, sz, &p, end) == -1)
396 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200397
398 /* "max-fram-size" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100399 sz = SLEN(MAX_FRAME_SIZE_KEY);
400 if (spoe_encode_buffer(MAX_FRAME_SIZE_KEY, sz, &p, end) == -1)
401 goto too_big;
402
403 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200404 if (encode_varint(SPOE_APPCTX(appctx)->max_frame_size, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100405 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200406
407 /* "capabilities" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100408 sz = SLEN(CAPABILITIES_KEY);
409 if (spoe_encode_buffer(CAPABILITIES_KEY, sz, &p, end) == -1)
410 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200411
Christopher Faulet8ef75252017-02-20 22:56:03 +0100412 *p++ = SPOE_DATA_T_STR;
Christopher Faulet305c6072017-02-23 16:17:53 +0100413 chk = get_trash_chunk();
414 if (agent != NULL && (agent->flags & SPOE_FL_PIPELINING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200415 memcpy(chk->area, "pipelining", 10);
416 chk->data += 10;
Christopher Faulet305c6072017-02-23 16:17:53 +0100417 }
418 if (agent != NULL && (agent->flags & SPOE_FL_ASYNC)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200419 if (chk->data) chk->area[chk->data++] = ',';
420 memcpy(chk->area+chk->data, "async", 5);
421 chk->data += 5;
Christopher Faulet305c6072017-02-23 16:17:53 +0100422 }
Christopher Fauletcecd8522017-02-24 22:11:21 +0100423 if (agent != NULL && (agent->flags & SPOE_FL_RCV_FRAGMENTATION)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200424 if (chk->data) chk->area[chk->data++] = ',';
425 memcpy(chk->area+chk->data, "fragmentation", 13);
Miroslav Zagorac6b3690b2019-01-13 16:55:01 +0100426 chk->data += 13;
Christopher Fauletcecd8522017-02-24 22:11:21 +0100427 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200428 if (spoe_encode_buffer(chk->area, chk->data, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100429 goto too_big;
430
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500431 /* (optional) "engine-id" K/V item, if present */
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200432 if (agent != NULL && agent->rt[tid].engine_id != NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100433 sz = SLEN(ENGINE_ID_KEY);
434 if (spoe_encode_buffer(ENGINE_ID_KEY, sz, &p, end) == -1)
435 goto too_big;
436
437 *p++ = SPOE_DATA_T_STR;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200438 sz = strlen(agent->rt[tid].engine_id);
439 if (spoe_encode_buffer(agent->rt[tid].engine_id, sz, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100440 goto too_big;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100441 }
442
Christopher Faulet8ef75252017-02-20 22:56:03 +0100443 return (p - frame);
444
445 too_big:
446 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
447 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200448}
449
Christopher Faulet8ef75252017-02-20 22:56:03 +0100450/* Encode DISCONNECT frame sent by HAProxy to an agent. It returns the number of
451 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
452 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200453static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100454spoe_prepare_hadiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200455{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100456 const char *reason;
457 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100458 unsigned int flags = SPOE_FRM_FL_FIN;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100459 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200460
Christopher Faulet8ef75252017-02-20 22:56:03 +0100461 p = frame;
462 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200463
Christopher Faulet8ef75252017-02-20 22:56:03 +0100464 /* Set Frame type */
465 *p++ = SPOE_FRM_T_HAPROXY_DISCON;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200466
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100467 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200468 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100469 memcpy(p, (char *)&flags, 4);
470 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200471
472 /* No stream-id and frame-id for DISCONNECT frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100473 *p++ = 0; *p++ = 0;
474
475 if (SPOE_APPCTX(appctx)->status_code >= SPOE_FRM_ERRS)
476 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200477
478 /* There are 2 mandatory items: "status-code" and "message" */
479
480 /* "status-code" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100481 sz = SLEN(STATUS_CODE_KEY);
482 if (spoe_encode_buffer(STATUS_CODE_KEY, sz, &p, end) == -1)
483 goto too_big;
484
485 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200486 if (encode_varint(SPOE_APPCTX(appctx)->status_code, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100487 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200488
489 /* "message" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100490 sz = SLEN(MSG_KEY);
491 if (spoe_encode_buffer(MSG_KEY, sz, &p, end) == -1)
492 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200493
Christopher Faulet8ef75252017-02-20 22:56:03 +0100494 /*Get the message corresponding to the status code */
495 reason = spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code];
496
497 *p++ = SPOE_DATA_T_STR;
498 sz = strlen(reason);
499 if (spoe_encode_buffer(reason, sz, &p, end) == -1)
500 goto too_big;
501
502 return (p - frame);
503
504 too_big:
505 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
506 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200507}
508
Christopher Faulet8ef75252017-02-20 22:56:03 +0100509/* Encode the NOTIFY frame sent by HAProxy to an agent. It returns the number of
510 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
511 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200512static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100513spoe_prepare_hanotify_frame(struct appctx *appctx, struct spoe_context *ctx,
Christopher Fauleta1cda022016-12-21 08:58:06 +0100514 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200515{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100516 char *p, *end;
517 unsigned int stream_id, frame_id;
518 unsigned int flags = SPOE_FRM_FL_FIN;
519 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200520
Christopher Faulet8ef75252017-02-20 22:56:03 +0100521 p = frame;
522 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200523
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100524 stream_id = ctx->stream_id;
525 frame_id = ctx->frame_id;
526
527 if (ctx->flags & SPOE_CTX_FL_FRAGMENTED) {
528 /* The fragmentation is not supported by the applet */
529 if (!(SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_FRAGMENTATION)) {
530 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
531 return -1;
532 }
533 flags = ctx->frag_ctx.flags;
534 }
535
536 /* Set Frame type */
537 *p++ = SPOE_FRM_T_HAPROXY_NOTIFY;
538
539 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200540 flags = htonl(flags);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100541 memcpy(p, (char *)&flags, 4);
542 p += 4;
543
544 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200545 if (encode_varint(stream_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100546 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200547 if (encode_varint(frame_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100548 goto too_big;
549
550 /* Copy encoded messages, if possible */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200551 sz = b_data(&ctx->buffer);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100552 if (p + sz >= end)
553 goto too_big;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200554 memcpy(p, b_head(&ctx->buffer), sz);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100555 p += sz;
556
557 return (p - frame);
558
559 too_big:
560 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
561 return 0;
562}
563
564/* Encode next part of a fragmented frame sent by HAProxy to an agent. It
565 * returns the number of encoded bytes in the frame on success, 0 if an encoding
566 * error occurred and -1 if a fatal error occurred. */
567static int
568spoe_prepare_hafrag_frame(struct appctx *appctx, struct spoe_context *ctx,
569 char *frame, size_t size)
570{
571 char *p, *end;
572 unsigned int stream_id, frame_id;
573 unsigned int flags;
574 size_t sz;
575
576 p = frame;
577 end = frame+size;
578
Christopher Faulet8ef75252017-02-20 22:56:03 +0100579 /* <ctx> is null when the stream has aborted the processing of a
580 * fragmented frame. In this case, we must notify the corresponding
581 * agent using ids stored in <frag_ctx>. */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100582 if (ctx == NULL) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100583 flags = (SPOE_FRM_FL_FIN|SPOE_FRM_FL_ABRT);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100584 stream_id = SPOE_APPCTX(appctx)->frag_ctx.cursid;
585 frame_id = SPOE_APPCTX(appctx)->frag_ctx.curfid;
586 }
587 else {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100588 flags = ctx->frag_ctx.flags;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100589 stream_id = ctx->stream_id;
590 frame_id = ctx->frame_id;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100591 }
592
Christopher Faulet8ef75252017-02-20 22:56:03 +0100593 /* Set Frame type */
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100594 *p++ = SPOE_FRM_T_UNSET;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100595
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100596 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200597 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100598 memcpy(p, (char *)&flags, 4);
599 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200600
601 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200602 if (encode_varint(stream_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100603 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200604 if (encode_varint(frame_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100605 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200606
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100607 if (ctx == NULL)
608 goto end;
609
Christopher Faulet8ef75252017-02-20 22:56:03 +0100610 /* Copy encoded messages, if possible */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200611 sz = b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100612 if (p + sz >= end)
613 goto too_big;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200614 memcpy(p, b_head(&ctx->buffer), sz);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100615 p += sz;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100616
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100617 end:
Christopher Faulet8ef75252017-02-20 22:56:03 +0100618 return (p - frame);
619
620 too_big:
621 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
622 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200623}
624
Christopher Faulet8ef75252017-02-20 22:56:03 +0100625/* Decode and process the HELLO frame sent by an agent. It returns the number of
626 * read bytes on success, 0 if a decoding error occurred, and -1 if a fatal
627 * error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200628static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100629spoe_handle_agenthello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200630{
Christopher Faulet305c6072017-02-23 16:17:53 +0100631 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
632 char *p, *end;
633 int vsn, max_frame_size;
634 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100635
636 p = frame;
637 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200638
639 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100640 if (*p++ != SPOE_FRM_T_AGENT_HELLO) {
641 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200642 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100643 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200644
Christopher Faulet8ef75252017-02-20 22:56:03 +0100645 if (size < 7 /* TYPE + METADATA */) {
646 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
647 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200648 }
649
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100650 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100651 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200652 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100653 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200654
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100655 /* Fragmentation is not supported for HELLO frame */
656 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100657 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100658 return -1;
659 }
660
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200661 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100662 if (*p != 0 || *(p+1) != 0) {
663 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
664 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200665 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100666 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200667
668 /* There are 3 mandatory items: "version", "max-frame-size" and
669 * "capabilities" */
670
671 /* Loop on K/V items */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100672 vsn = max_frame_size = flags = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100673 while (p < end) {
674 char *str;
Frédéric Lécaille6ca71a92017-08-22 10:33:14 +0200675 uint64_t sz;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100676 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200677
678 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100679 ret = spoe_decode_buffer(&p, end, &str, &sz);
680 if (ret == -1 || !sz) {
681 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
682 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200683 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100684
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200685 /* Check "version" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200686 if (sz >= strlen(VERSION_KEY) && !memcmp(str, VERSION_KEY, strlen(VERSION_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100687 int i, type = *p++;
688
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200689 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100690 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
691 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
692 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200693 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100694 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
695 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
696 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200697 }
698
Christopher Faulet8ef75252017-02-20 22:56:03 +0100699 vsn = spoe_str_to_vsn(str, sz);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200700 if (vsn == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100701 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200702 return -1;
703 }
704 for (i = 0; supported_versions[i].str != NULL; ++i) {
705 if (vsn >= supported_versions[i].min &&
706 vsn <= supported_versions[i].max)
707 break;
708 }
709 if (supported_versions[i].str == NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100710 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200711 return -1;
712 }
713 }
714 /* Check "max-frame-size" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200715 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 +0100716 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200717
718 /* The value must be integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200719 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
720 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
721 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
722 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100723 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
724 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200725 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200726 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100727 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
728 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200729 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100730 if (sz < MIN_FRAME_SIZE ||
731 sz > SPOE_APPCTX(appctx)->max_frame_size) {
732 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200733 return -1;
734 }
735 max_frame_size = sz;
736 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100737 /* Check "capabilities" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200738 else if (sz >= strlen(CAPABILITIES_KEY) && !memcmp(str, CAPABILITIES_KEY, strlen(CAPABILITIES_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100739 int type = *p++;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100740
741 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100742 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
743 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
744 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100745 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100746 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
747 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
748 return 0;
749 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100750
Christopher Faulet8ef75252017-02-20 22:56:03 +0100751 while (sz) {
Christopher Fauleta1cda022016-12-21 08:58:06 +0100752 char *delim;
753
754 /* Skip leading spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100755 for (; isspace((unsigned char)*str) && sz; str++, sz--);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100756
Christopher Faulet8ef75252017-02-20 22:56:03 +0100757 if (sz >= 10 && !strncmp(str, "pipelining", 10)) {
758 str += 10; sz -= 10;
Willy Tarreau90807112020-02-25 08:16:33 +0100759 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100760 flags |= SPOE_APPCTX_FL_PIPELINING;
761 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100762 else if (sz >= 5 && !strncmp(str, "async", 5)) {
763 str += 5; sz -= 5;
Willy Tarreau90807112020-02-25 08:16:33 +0100764 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100765 flags |= SPOE_APPCTX_FL_ASYNC;
766 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100767 else if (sz >= 13 && !strncmp(str, "fragmentation", 13)) {
768 str += 13; sz -= 13;
Willy Tarreau90807112020-02-25 08:16:33 +0100769 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100770 flags |= SPOE_APPCTX_FL_FRAGMENTATION;
771 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100772
Christopher Faulet8ef75252017-02-20 22:56:03 +0100773 /* Get the next comma or break */
774 if (!sz || (delim = memchr(str, ',', sz)) == NULL)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100775 break;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100776 delim++;
777 sz -= (delim - str);
778 str = delim;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100779 }
780 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200781 else {
782 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100783 if (spoe_skip_data(&p, end) == -1) {
784 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
785 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200786 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200787 }
788 }
789
790 /* Final checks */
791 if (!vsn) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100792 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200793 return -1;
794 }
795 if (!max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100796 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200797 return -1;
798 }
Christopher Faulet11389012019-02-07 16:13:26 +0100799 if (!agent)
800 flags &= ~(SPOE_APPCTX_FL_PIPELINING|SPOE_APPCTX_FL_ASYNC);
801 else {
802 if ((flags & SPOE_APPCTX_FL_PIPELINING) && !(agent->flags & SPOE_FL_PIPELINING))
803 flags &= ~SPOE_APPCTX_FL_PIPELINING;
804 if ((flags & SPOE_APPCTX_FL_ASYNC) && !(agent->flags & SPOE_FL_ASYNC))
805 flags &= ~SPOE_APPCTX_FL_ASYNC;
806 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200807
Christopher Faulet42bfa462017-01-04 14:14:19 +0100808 SPOE_APPCTX(appctx)->version = (unsigned int)vsn;
809 SPOE_APPCTX(appctx)->max_frame_size = (unsigned int)max_frame_size;
810 SPOE_APPCTX(appctx)->flags |= flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100811
812 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200813}
814
815/* Decode DISCONNECT frame sent by an agent. It returns the number of by read
816 * bytes on success, 0 if the frame can be ignored and -1 if an error
817 * occurred. */
818static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100819spoe_handle_agentdiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200820{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100821 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100822 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100823
824 p = frame;
825 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200826
827 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100828 if (*p++ != SPOE_FRM_T_AGENT_DISCON) {
829 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200830 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100831 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200832
Christopher Faulet8ef75252017-02-20 22:56:03 +0100833 if (size < 7 /* TYPE + METADATA */) {
834 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
835 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200836 }
837
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100838 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100839 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200840 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100841 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200842
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100843 /* Fragmentation is not supported for DISCONNECT frame */
844 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100845 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100846 return -1;
847 }
848
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200849 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100850 if (*p != 0 || *(p+1) != 0) {
851 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
852 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200853 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100854 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200855
856 /* There are 2 mandatory items: "status-code" and "message" */
857
858 /* Loop on K/V items */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100859 while (p < end) {
860 char *str;
Frédéric Lécaille6ca71a92017-08-22 10:33:14 +0200861 uint64_t sz;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100862 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200863
864 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100865 ret = spoe_decode_buffer(&p, end, &str, &sz);
866 if (ret == -1 || !sz) {
867 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
868 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200869 }
870
871 /* Check "status-code" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200872 if (sz >= strlen(STATUS_CODE_KEY) && !memcmp(str, STATUS_CODE_KEY, strlen(STATUS_CODE_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100873 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200874
875 /* The value must be an integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200876 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
877 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
878 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
879 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100880 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
881 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200882 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200883 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100884 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
885 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200886 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100887 SPOE_APPCTX(appctx)->status_code = sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200888 }
889
890 /* Check "message" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200891 else if (sz >= strlen(MSG_KEY) && !memcmp(str, MSG_KEY, strlen(MSG_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100892 int type = *p++;
893
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200894 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100895 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
896 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
897 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200898 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100899 ret = spoe_decode_buffer(&p, end, &str, &sz);
900 if (ret == -1 || sz > 255) {
901 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
902 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200903 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100904#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
905 SPOE_APPCTX(appctx)->reason = str;
906 SPOE_APPCTX(appctx)->rlen = sz;
907#endif
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200908 }
909 else {
910 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100911 if (spoe_skip_data(&p, end) == -1) {
912 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
913 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200914 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200915 }
916 }
917
Christopher Faulet8ef75252017-02-20 22:56:03 +0100918 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200919}
920
921
Christopher Fauleta1cda022016-12-21 08:58:06 +0100922/* Decode ACK frame sent by an agent. It returns the number of read bytes on
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200923 * success, 0 if the frame can be ignored and -1 if an error occurred. */
924static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100925spoe_handle_agentack_frame(struct appctx *appctx, struct spoe_context **ctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100926 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200927{
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100928 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100929 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100930 uint64_t stream_id, frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100931 int len;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100932 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100933
934 p = frame;
935 end = frame + size;
936 *ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200937
938 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100939 if (*p++ != SPOE_FRM_T_AGENT_ACK) {
940 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200941 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100942 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200943
Christopher Faulet8ef75252017-02-20 22:56:03 +0100944 if (size < 7 /* TYPE + METADATA */) {
945 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
946 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200947 }
948
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100949 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100950 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200951 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100952 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200953
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100954 /* Fragmentation is not supported for now */
955 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100956 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100957 return -1;
958 }
959
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200960 /* Get the stream-id and the frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200961 if (decode_varint(&p, end, &stream_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100962 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100963 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100964 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200965 if (decode_varint(&p, end, &frame_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100966 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200967 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100968 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100969
Christopher Faulet8ef75252017-02-20 22:56:03 +0100970 /* Try to find the corresponding SPOE context */
Christopher Faulet42bfa462017-01-04 14:14:19 +0100971 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
Christopher Faulet24289f22017-09-25 14:48:02 +0200972 list_for_each_entry((*ctx), &agent->rt[tid].waiting_queue, list) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100973 if ((*ctx)->stream_id == (unsigned int)stream_id &&
974 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100975 goto found;
976 }
977 }
978 else {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100979 list_for_each_entry((*ctx), &SPOE_APPCTX(appctx)->waiting_queue, list) {
980 if ((*ctx)->stream_id == (unsigned int)stream_id &&
Christopher Faulet8ef75252017-02-20 22:56:03 +0100981 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100982 goto found;
983 }
984 }
985
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100986 if (SPOE_APPCTX(appctx)->frag_ctx.ctx &&
987 SPOE_APPCTX(appctx)->frag_ctx.cursid == (unsigned int)stream_id &&
988 SPOE_APPCTX(appctx)->frag_ctx.curfid == (unsigned int)frame_id) {
989
990 /* ABRT bit is set for an unfinished fragmented frame */
991 if (flags & SPOE_FRM_FL_ABRT) {
992 *ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100993 (*ctx)->state = SPOE_CTX_ST_ERROR;
994 (*ctx)->status_code = SPOE_CTX_ERR_FRAG_FRAME_ABRT;
995 /* Ignore the payload */
996 goto end;
997 }
998 /* TODO: Handle more flags for fragmented frames: RESUME, FINISH... */
999 /* For now, we ignore the ack */
1000 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
1001 return 0;
1002 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001003
Christopher Fauleta1cda022016-12-21 08:58:06 +01001004 /* No Stream found, ignore the frame */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001005 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1006 " - Ignore ACK frame"
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001007 " - stream-id=%u - frame-id=%u\n",
1008 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1009 __FUNCTION__, appctx,
1010 (unsigned int)stream_id, (unsigned int)frame_id);
1011
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001012 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAMEID_NOTFOUND;
Christopher Fauletc7ba9102020-11-10 14:31:39 +01001013 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK) {
1014 /* Report an error if we are waiting the ack for another frame,
1015 * but not if there is no longer frame waiting for a ack
1016 * (timeout)
1017 */
1018 if (!LIST_ISEMPTY(&SPOE_APPCTX(appctx)->waiting_queue) ||
1019 SPOE_APPCTX(appctx)->frag_ctx.ctx)
1020 return -1;
1021 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1022 SPOE_APPCTX(appctx)->cur_fpa = 0;
1023 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001024 return 0;
1025
1026 found:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001027 if (!spoe_acquire_buffer(&SPOE_APPCTX(appctx)->buffer,
1028 &SPOE_APPCTX(appctx)->buffer_wait)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001029 *ctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001030 return 1; /* Retry later */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001031 }
Christopher Faulet4596fb72017-01-11 14:05:19 +01001032
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001033 /* Copy encoded actions */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001034 len = (end - p);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001035 memcpy(b_head(&SPOE_APPCTX(appctx)->buffer), p, len);
1036 b_set_data(&SPOE_APPCTX(appctx)->buffer, len);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001037 p += len;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001038
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001039 /* Transfer the buffer ownership to the SPOE context */
1040 (*ctx)->buffer = SPOE_APPCTX(appctx)->buffer;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001041 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001042
Christopher Faulet8ef75252017-02-20 22:56:03 +01001043 (*ctx)->state = SPOE_CTX_ST_DONE;
1044
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001045 end:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001046 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001047 " - ACK frame received"
1048 " - ctx=%p - stream-id=%u - frame-id=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001049 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001050 __FUNCTION__, appctx, *ctx, (*ctx)->stream_id,
1051 (*ctx)->frame_id, flags);
1052 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001053}
1054
Christopher Fauletba7bc162016-11-07 21:07:38 +01001055/* This function is used in cfgparse.c and declared in proto/checks.h. It
1056 * prepare the request to send to agents during a healthcheck. It returns 0 on
1057 * success and -1 if an error occurred. */
1058int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001059spoe_prepare_healthcheck_request(char **req, int *len)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001060{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001061 struct appctx appctx;
1062 struct spoe_appctx spoe_appctx;
1063 char *frame, *end, buf[MAX_FRAME_SIZE+4];
1064 size_t sz;
1065 int ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001066
Christopher Faulet42bfa462017-01-04 14:14:19 +01001067 memset(&appctx, 0, sizeof(appctx));
1068 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001069 memset(buf, 0, sizeof(buf));
Christopher Faulet42bfa462017-01-04 14:14:19 +01001070
1071 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001072 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001073
Christopher Faulet8ef75252017-02-20 22:56:03 +01001074 frame = buf+4; /* Reserved the 4 first bytes for the frame size */
1075 end = frame + MAX_FRAME_SIZE;
1076
1077 ret = spoe_prepare_hahello_frame(&appctx, frame, MAX_FRAME_SIZE);
1078 if (ret <= 0)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001079 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001080 frame += ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001081
Christopher Faulet8ef75252017-02-20 22:56:03 +01001082 /* Add "healthcheck" K/V item */
1083 sz = SLEN(HEALTHCHECK_KEY);
1084 if (spoe_encode_buffer(HEALTHCHECK_KEY, sz, &frame, end) == -1)
1085 return -1;
1086 *frame++ = (SPOE_DATA_T_BOOL | SPOE_DATA_FL_TRUE);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001087
Christopher Faulet8ef75252017-02-20 22:56:03 +01001088 *len = frame - buf;
1089 sz = htonl(*len - 4);
1090 memcpy(buf, (char *)&sz, 4);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001091
Christopher Faulet8ef75252017-02-20 22:56:03 +01001092 if ((*req = malloc(*len)) == NULL)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001093 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001094 memcpy(*req, buf, *len);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001095 return 0;
1096}
1097
1098/* This function is used in checks.c and declared in proto/checks.h. It decode
1099 * the response received from an agent during a healthcheck. It returns 0 on
1100 * success and -1 if an error occurred. */
1101int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001102spoe_handle_healthcheck_response(char *frame, size_t size, char *err, int errlen)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001103{
Christopher Faulet42bfa462017-01-04 14:14:19 +01001104 struct appctx appctx;
1105 struct spoe_appctx spoe_appctx;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001106
Christopher Faulet42bfa462017-01-04 14:14:19 +01001107 memset(&appctx, 0, sizeof(appctx));
1108 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001109
Christopher Faulet42bfa462017-01-04 14:14:19 +01001110 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001111 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001112
Christopher Faulet8ef75252017-02-20 22:56:03 +01001113 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1114 spoe_handle_agentdiscon_frame(&appctx, frame, size);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001115 goto error;
1116 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001117 if (spoe_handle_agenthello_frame(&appctx, frame, size) <= 0)
1118 goto error;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001119
1120 return 0;
1121
1122 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001123 if (SPOE_APPCTX(&appctx)->status_code >= SPOE_FRM_ERRS)
1124 SPOE_APPCTX(&appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
1125 strncpy(err, spoe_frm_err_reasons[SPOE_APPCTX(&appctx)->status_code], errlen);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001126 return -1;
1127}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001128
Christopher Fauleta1cda022016-12-21 08:58:06 +01001129/* Send a SPOE frame to an agent. It returns -1 when an error occurred, 0 when
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05001130 * the frame can be ignored, 1 to retry later, and the frame length on
Christopher Fauleta1cda022016-12-21 08:58:06 +01001131 * success. */
1132static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001133spoe_send_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001134{
1135 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001136 int ret;
1137 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001138
Christopher Faulet8ef75252017-02-20 22:56:03 +01001139 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1140 * length. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001141 netint = htonl(framesz);
1142 memcpy(buf, (char *)&netint, 4);
Willy Tarreau06d80a92017-10-19 14:32:15 +02001143 ret = ci_putblk(si_ic(si), buf, framesz+4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001144 if (ret <= 0) {
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001145 if ((ret == -3 && b_is_null(&si_ic(si)->buf)) || ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001146 si_rx_room_blk(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001147 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001148 }
1149 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001150 return -1; /* error */
1151 }
1152 return framesz;
1153}
1154
1155/* Receive a SPOE frame from an agent. It return -1 when an error occurred, 0
1156 * when the frame can be ignored, 1 to retry later and the frame length on
1157 * success. */
1158static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001159spoe_recv_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001160{
1161 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001162 int ret;
1163 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001164
Willy Tarreau06d80a92017-10-19 14:32:15 +02001165 ret = co_getblk(si_oc(si), (char *)&netint, 4, 0);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001166 if (ret > 0) {
1167 framesz = ntohl(netint);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001168 if (framesz > SPOE_APPCTX(appctx)->max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001169 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001170 return -1;
1171 }
Willy Tarreau06d80a92017-10-19 14:32:15 +02001172 ret = co_getblk(si_oc(si), buf, framesz, 4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001173 }
1174 if (ret <= 0) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001175 if (ret == 0) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001176 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001177 }
1178 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001179 return -1; /* error */
1180 }
1181 return framesz;
1182}
1183
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001184/********************************************************************
1185 * Functions that manage the SPOE applet
1186 ********************************************************************/
Christopher Faulet4596fb72017-01-11 14:05:19 +01001187static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001188spoe_wakeup_appctx(struct appctx *appctx)
Christopher Faulet4596fb72017-01-11 14:05:19 +01001189{
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001190 si_want_get(appctx->owner);
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001191 si_rx_endp_more(appctx->owner);
Christopher Faulet4596fb72017-01-11 14:05:19 +01001192 appctx_wakeup(appctx);
1193 return 1;
1194}
1195
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001196/* Callback function that catches applet timeouts. If a timeout occurred, we set
1197 * <appctx->st1> flag and the SPOE applet is woken up. */
1198static struct task *
Willy Tarreau144f84a2021-03-02 16:09:26 +01001199spoe_process_appctx(struct task * task, void *context, unsigned int state)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001200{
Olivier Houchard9f6af332018-05-25 14:04:04 +02001201 struct appctx *appctx = context;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001202
1203 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1204 if (tick_is_expired(task->expire, now_ms)) {
1205 task->expire = TICK_ETERNITY;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001206 appctx->st1 = SPOE_APPCTX_ERR_TOUT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001207 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001208 spoe_wakeup_appctx(appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001209 return task;
1210}
1211
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001212/* Callback function that releases a SPOE applet. This happens when the
1213 * connection with the agent is closed. */
1214static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001215spoe_release_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001216{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001217 struct stream_interface *si = appctx->owner;
1218 struct spoe_appctx *spoe_appctx = SPOE_APPCTX(appctx);
1219 struct spoe_agent *agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001220 struct spoe_context *ctx, *back;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001221
1222 if (spoe_appctx == NULL)
1223 return;
1224
1225 appctx->ctx.spoe.ptr = NULL;
1226 agent = spoe_appctx->agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001227
1228 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p\n",
1229 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1230 __FUNCTION__, appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001231
Christopher Faulet8ef75252017-02-20 22:56:03 +01001232 /* Remove applet from the list of running applets */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001233 _HA_ATOMIC_SUB(&agent->counters.applets, 1);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001234 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001235 if (!LIST_ISEMPTY(&spoe_appctx->list)) {
1236 LIST_DEL(&spoe_appctx->list);
1237 LIST_INIT(&spoe_appctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001238 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001239 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001240
Christopher Faulet8ef75252017-02-20 22:56:03 +01001241 /* Shutdown the server connection, if needed */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001242 if (appctx->st0 != SPOE_APPCTX_ST_END) {
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001243 if (appctx->st0 == SPOE_APPCTX_ST_IDLE) {
1244 eb32_delete(&spoe_appctx->node);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001245 _HA_ATOMIC_SUB(&agent->counters.idles, 1);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001246 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001247
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001248 appctx->st0 = SPOE_APPCTX_ST_END;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001249 if (spoe_appctx->status_code == SPOE_FRM_ERR_NONE)
1250 spoe_appctx->status_code = SPOE_FRM_ERR_IO;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001251
1252 si_shutw(si);
1253 si_shutr(si);
1254 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001255 }
1256
Christopher Faulet8ef75252017-02-20 22:56:03 +01001257 /* Destroy the task attached to this applet */
Willy Tarreauf6562792019-05-07 19:05:35 +02001258 task_destroy(spoe_appctx->task);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001259
Christopher Faulet8ef75252017-02-20 22:56:03 +01001260 /* Notify all waiting streams */
1261 list_for_each_entry_safe(ctx, back, &spoe_appctx->waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001262 LIST_DEL(&ctx->list);
1263 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001264 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001265 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauletcf181c72020-11-10 18:45:34 +01001266 ctx->spoe_appctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001267 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001268 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001269 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001270 }
1271
Christopher Faulet8ef75252017-02-20 22:56:03 +01001272 /* If the applet was processing a fragmented frame, notify the
1273 * corresponding stream. */
1274 if (spoe_appctx->frag_ctx.ctx) {
1275 ctx = spoe_appctx->frag_ctx.ctx;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001276 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001277 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001278 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001279 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1280 }
1281
Christopher Fauletcf181c72020-11-10 18:45:34 +01001282 if (!LIST_ISEMPTY(&agent->rt[tid].applets)) {
1283 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
1284 if (ctx->spoe_appctx == spoe_appctx)
1285 ctx->spoe_appctx = NULL;
1286 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001287 goto end;
Christopher Fauletcf181c72020-11-10 18:45:34 +01001288 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001289
Christopher Faulet8ef75252017-02-20 22:56:03 +01001290 /* If this was the last running applet, notify all waiting streams */
Christopher Faulet24289f22017-09-25 14:48:02 +02001291 list_for_each_entry_safe(ctx, back, &agent->rt[tid].sending_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001292 LIST_DEL(&ctx->list);
1293 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001294 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001295 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletcf181c72020-11-10 18:45:34 +01001296 ctx->spoe_appctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001297 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001298 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001299 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001300 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001301 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001302 LIST_DEL(&ctx->list);
1303 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001304 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001305 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauletcf181c72020-11-10 18:45:34 +01001306 ctx->spoe_appctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001307 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001308 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001309 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1310 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001311
1312 end:
Christopher Faulet55ae8a62019-05-23 22:47:48 +02001313 /* Release allocated memory */
1314 spoe_release_buffer(&spoe_appctx->buffer,
1315 &spoe_appctx->buffer_wait);
1316 pool_free(pool_head_spoe_appctx, spoe_appctx);
1317
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001318 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001319 agent->rt[tid].frame_size = agent->max_frame_size;
1320 list_for_each_entry(spoe_appctx, &agent->rt[tid].applets, list)
1321 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, spoe_appctx->max_frame_size);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001322}
1323
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001324static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001325spoe_handle_connect_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001326{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001327 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001328 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001329 char *frame, *buf;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001330 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001331
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001332 if (si_state_in(si->state, SI_SB_CER|SI_SB_DIS|SI_SB_CLO)) {
1333 /* closed */
1334 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1335 goto exit;
1336 }
1337
Willy Tarreau4f283fa2019-06-05 14:34:03 +02001338 if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST)) {
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001339 /* not connected yet */
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001340 si_rx_endp_more(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001341 task_wakeup(si_strm(si)->task, TASK_WOKEN_MSG);
1342 goto stop;
1343 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001344
Christopher Fauleta1cda022016-12-21 08:58:06 +01001345 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001346 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1347 " - Connection timed out\n",
1348 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1349 __FUNCTION__, appctx);
1350 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001351 goto exit;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001352 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001353
Christopher Faulet42bfa462017-01-04 14:14:19 +01001354 if (SPOE_APPCTX(appctx)->task->expire == TICK_ETERNITY)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001355 SPOE_APPCTX(appctx)->task->expire =
1356 tick_add_ifset(now_ms, agent->timeout.hello);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001357
Christopher Faulet8ef75252017-02-20 22:56:03 +01001358 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1359 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001360 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001361 ret = spoe_prepare_hahello_frame(appctx, frame,
1362 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001363 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001364 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001365
1366 switch (ret) {
1367 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001368 case 0: /* ignore => an error, cannot be ignored */
1369 goto exit;
1370
1371 case 1: /* retry later */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001372 goto stop;
1373
Christopher Faulet8ef75252017-02-20 22:56:03 +01001374 default:
1375 /* HELLO frame successfully sent, now wait for the
1376 * reply. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001377 appctx->st0 = SPOE_APPCTX_ST_CONNECTING;
1378 goto next;
1379 }
1380
1381 next:
1382 return 0;
1383 stop:
1384 return 1;
1385 exit:
1386 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1387 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001388}
1389
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001390static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001391spoe_handle_connecting_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001392{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001393 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001394 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001395 char *frame;
1396 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001397
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001398
Christopher Fauletb067b062017-01-04 16:39:11 +01001399 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001400 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001401 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001402 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001403
Christopher Fauleta1cda022016-12-21 08:58:06 +01001404 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001405 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1406 " - Connection timed out\n",
1407 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1408 __FUNCTION__, appctx);
1409 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001410 goto exit;
1411 }
1412
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001413 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001414 ret = spoe_recv_frame(appctx, frame,
1415 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001416 if (ret > 1) {
1417 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1418 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1419 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001420 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001421 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001422 ret = spoe_handle_agenthello_frame(appctx, frame, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001423 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001424
Christopher Fauleta1cda022016-12-21 08:58:06 +01001425 switch (ret) {
1426 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001427 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001428 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1429 goto next;
1430
1431 case 1: /* retry later */
1432 goto stop;
1433
1434 default:
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001435 _HA_ATOMIC_ADD(&agent->counters.idles, 1);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001436 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001437 SPOE_APPCTX(appctx)->node.key = 0;
1438 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001439
1440 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001441 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001442 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001443 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001444
Christopher Fauleta1cda022016-12-21 08:58:06 +01001445 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001446 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001447 if (trash.data)
1448 co_skip(si_oc(si), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001449
1450 SPOE_APPCTX(appctx)->task->expire =
1451 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001452 return 0;
1453 stop:
1454 return 1;
1455 exit:
1456 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1457 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001458}
1459
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001460
Christopher Fauleta1cda022016-12-21 08:58:06 +01001461static int
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001462spoe_handle_sending_frame_appctx(struct appctx *appctx, int *skip)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001463{
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001464 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
1465 struct spoe_context *ctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001466 char *frame, *buf;
1467 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001468
Christopher Faulet8ef75252017-02-20 22:56:03 +01001469 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1470 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001471 buf = trash.area; frame = buf+4;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001472
1473 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY) {
1474 ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
1475 ret = spoe_prepare_hafrag_frame(appctx, ctx, frame,
1476 SPOE_APPCTX(appctx)->max_frame_size);
1477 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001478 else if (LIST_ISEMPTY(&agent->rt[tid].sending_queue)) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001479 *skip = 1;
1480 ret = 1;
1481 goto end;
1482 }
1483 else {
Christopher Faulet24289f22017-09-25 14:48:02 +02001484 ctx = LIST_NEXT(&agent->rt[tid].sending_queue, typeof(ctx), list);
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001485 ret = spoe_prepare_hanotify_frame(appctx, ctx, frame,
1486 SPOE_APPCTX(appctx)->max_frame_size);
1487
1488 }
1489
Christopher Faulet8ef75252017-02-20 22:56:03 +01001490 if (ret > 1)
1491 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001492
Christopher Faulet8ef75252017-02-20 22:56:03 +01001493 switch (ret) {
1494 case -1: /* error */
1495 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1496 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001497
Christopher Faulet8ef75252017-02-20 22:56:03 +01001498 case 0: /* ignore */
1499 if (ctx == NULL)
1500 goto abort_frag_frame;
1501
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001502 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001503 LIST_DEL(&ctx->list);
1504 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001505 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001506 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001507 ctx->spoe_appctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001508 ctx->state = SPOE_CTX_ST_ERROR;
1509 ctx->status_code = (SPOE_APPCTX(appctx)->status_code + 0x100);
1510 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001511 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001512 break;
1513
1514 case 1: /* retry */
1515 *skip = 1;
1516 break;
1517
1518 default:
1519 if (ctx == NULL)
1520 goto abort_frag_frame;
1521
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001522 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001523 LIST_DEL(&ctx->list);
1524 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001525 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001526 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001527 ctx->spoe_appctx = SPOE_APPCTX(appctx);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001528 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) ||
1529 (ctx->frag_ctx.flags & SPOE_FRM_FL_FIN))
1530 goto no_frag_frame_sent;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001531 else
Christopher Faulet8ef75252017-02-20 22:56:03 +01001532 goto frag_frame_sent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001533 }
1534 goto end;
1535
1536 frag_frame_sent:
1537 appctx->st0 = SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001538 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001539 SPOE_APPCTX(appctx)->frag_ctx.ctx = ctx;
1540 SPOE_APPCTX(appctx)->frag_ctx.cursid = ctx->stream_id;
1541 SPOE_APPCTX(appctx)->frag_ctx.curfid = ctx->frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001542 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
1543 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1544 goto end;
1545
1546 no_frag_frame_sent:
1547 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
1548 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet24289f22017-09-25 14:48:02 +02001549 LIST_ADDQ(&agent->rt[tid].waiting_queue, &ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001550 }
1551 else if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_PIPELINING) {
1552 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1553 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1554 }
1555 else {
1556 appctx->st0 = SPOE_APPCTX_ST_WAITING_SYNC_ACK;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001557 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001558 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1559 }
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001560 _HA_ATOMIC_ADD(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001561 ctx->stats.tv_wait = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001562 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1563 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1564 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001565 SPOE_APPCTX(appctx)->cur_fpa++;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001566
Christopher Faulet8ef75252017-02-20 22:56:03 +01001567 ctx->state = SPOE_CTX_ST_WAITING_ACK;
1568 goto end;
1569
1570 abort_frag_frame:
1571 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1572 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1573 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1574 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1575 goto end;
1576
1577 end:
1578 return ret;
1579}
1580
1581static int
1582spoe_handle_receiving_frame_appctx(struct appctx *appctx, int *skip)
1583{
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02001584 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001585 struct spoe_context *ctx = NULL;
1586 char *frame;
1587 int ret;
1588
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001589 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001590 ret = spoe_recv_frame(appctx, frame,
1591 SPOE_APPCTX(appctx)->max_frame_size);
1592 if (ret > 1) {
1593 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1594 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001595 ret = -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001596 goto end;
1597 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001598 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001599 ret = spoe_handle_agentack_frame(appctx, &ctx, frame, ret);
1600 }
1601 switch (ret) {
1602 case -1: /* error */
1603 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1604 break;
1605
1606 case 0: /* ignore */
1607 break;
1608
1609 case 1: /* retry */
1610 *skip = 1;
1611 break;
1612
1613 default:
1614 LIST_DEL(&ctx->list);
1615 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001616 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001617 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
1618 ctx->stats.tv_response = now;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001619 if (ctx->spoe_appctx) {
1620 ctx->spoe_appctx->cur_fpa--;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001621 ctx->spoe_appctx = NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001622 }
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001623 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY &&
1624 ctx == SPOE_APPCTX(appctx)->frag_ctx.ctx) {
1625 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1626 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1627 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1628 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1629 }
1630 else if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1631 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001632 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1633 break;
1634 }
1635
1636 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001637 if (trash.data)
1638 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001639 end:
1640 return ret;
1641}
1642
1643static int
1644spoe_handle_processing_appctx(struct appctx *appctx)
1645{
1646 struct stream_interface *si = appctx->owner;
1647 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001648 int ret, skip_sending = 0, skip_receiving = 0, active_s = 0, active_r = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001649
1650 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
1651 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1652 goto exit;
1653 }
1654
1655 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
1656 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
1657 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1658 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1659 goto next;
1660 }
1661
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001662 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001663 " - process: fpa=%u/%u - appctx-state=%s - weight=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001664 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8f82b202018-01-24 16:23:03 +01001665 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->cur_fpa,
1666 agent->max_fpa, spoe_appctx_state_str[appctx->st0],
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001667 SPOE_APPCTX(appctx)->node.key, SPOE_APPCTX(appctx)->flags);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001668
Christopher Faulet8f82b202018-01-24 16:23:03 +01001669 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1670 skip_sending = 1;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001671
Christopher Faulet8f82b202018-01-24 16:23:03 +01001672 /* receiving_frame loop */
1673 while (!skip_receiving) {
1674 ret = spoe_handle_receiving_frame_appctx(appctx, &skip_receiving);
1675 switch (ret) {
1676 case -1: /* error */
1677 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001678
Christopher Faulet8f82b202018-01-24 16:23:03 +01001679 case 0: /* ignore */
1680 active_r = 1;
1681 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001682
Christopher Faulet8f82b202018-01-24 16:23:03 +01001683 case 1: /* retry */
1684 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001685
Christopher Faulet8f82b202018-01-24 16:23:03 +01001686 default:
1687 active_r = 1;
1688 break;
1689 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001690 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001691
Christopher Faulet8f82b202018-01-24 16:23:03 +01001692 /* send_frame loop */
1693 while (!skip_sending && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
1694 ret = spoe_handle_sending_frame_appctx(appctx, &skip_sending);
1695 switch (ret) {
1696 case -1: /* error */
1697 goto next;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001698
Christopher Faulet8f82b202018-01-24 16:23:03 +01001699 case 0: /* ignore */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001700 if (SPOE_APPCTX(appctx)->node.key)
1701 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001702 active_s++;
1703 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001704
Christopher Faulet8f82b202018-01-24 16:23:03 +01001705 case 1: /* retry */
1706 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001707
Christopher Faulet8f82b202018-01-24 16:23:03 +01001708 default:
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001709 if (SPOE_APPCTX(appctx)->node.key)
1710 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001711 active_s++;
1712 break;
1713 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001714 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001715
Christopher Faulet8f82b202018-01-24 16:23:03 +01001716 if (active_s || active_r) {
Christopher Faulet8f82b202018-01-24 16:23:03 +01001717 update_freq_ctr(&agent->rt[tid].processing_per_sec, active_s);
1718 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1719 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001720
Christopher Faulet8f82b202018-01-24 16:23:03 +01001721 if (appctx->st0 == SPOE_APPCTX_ST_PROCESSING && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
Christopher Faulet9e647e52021-03-01 15:01:14 +01001722 struct server *srv = objt_server(si_strm(si)->target);
1723
1724 /* With several threads, close the applet if there are pending
1725 * connections or if the server is full. Otherwise, add the
1726 * applet in the idle list.
1727 */
1728 if (global.nbthread > 1 &&
1729 (agent->b.be->nbpend ||
1730 (srv && (srv->nbpend || (srv->maxconn && srv->served >=srv_dynamic_maxconn(srv)))))) {
1731 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
1732 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1733 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1734 goto next;
1735 }
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001736 _HA_ATOMIC_ADD(&agent->counters.idles, 1);
Christopher Faulet8f82b202018-01-24 16:23:03 +01001737 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001738 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001739 }
1740 return 1;
1741
Christopher Faulet8f82b202018-01-24 16:23:03 +01001742 next:
1743 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1744 return 0;
1745
Christopher Fauleta1cda022016-12-21 08:58:06 +01001746 exit:
1747 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1748 return 0;
1749}
1750
1751static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001752spoe_handle_disconnect_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001753{
1754 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001755 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001756 char *frame, *buf;
1757 int ret;
Christopher Fauletb067b062017-01-04 16:39:11 +01001758
Christopher Fauleta1cda022016-12-21 08:58:06 +01001759 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO)
1760 goto exit;
1761
1762 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT)
1763 goto exit;
1764
Christopher Faulet8ef75252017-02-20 22:56:03 +01001765 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1766 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001767 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001768 ret = spoe_prepare_hadiscon_frame(appctx, frame,
1769 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001770 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001771 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001772
1773 switch (ret) {
1774 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001775 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001776 goto exit;
1777
1778 case 1: /* retry */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001779 goto stop;
1780
1781 default:
1782 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1783 " - disconnected by HAProxy (%d): %s\n",
1784 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001785 __FUNCTION__, appctx,
1786 SPOE_APPCTX(appctx)->status_code,
1787 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001788
1789 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1790 goto next;
1791 }
1792
1793 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001794 SPOE_APPCTX(appctx)->task->expire =
1795 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001796 return 0;
1797 stop:
1798 return 1;
1799 exit:
1800 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1801 return 0;
1802}
1803
1804static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001805spoe_handle_disconnecting_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001806{
1807 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001808 char *frame;
1809 int ret;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001810
Christopher Fauletb067b062017-01-04 16:39:11 +01001811 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001812 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001813 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001814 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001815
Christopher Fauletb067b062017-01-04 16:39:11 +01001816 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001817 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001818 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001819 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001820
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001821 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001822 ret = spoe_recv_frame(appctx, frame,
1823 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001824 if (ret > 1) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001825 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001826 ret = spoe_handle_agentdiscon_frame(appctx, frame, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001827 }
1828
1829 switch (ret) {
1830 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001831 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1832 " - error on frame (%s)\n",
1833 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001834 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Fauleta1cda022016-12-21 08:58:06 +01001835 __FUNCTION__, appctx,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001836 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001837 goto exit;
1838
1839 case 0: /* ignore */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001840 goto next;
1841
1842 case 1: /* retry */
1843 goto stop;
1844
1845 default:
Christopher Fauleta1cda022016-12-21 08:58:06 +01001846 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001847 " - disconnected by peer (%d): %.*s\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01001848 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001849 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001850 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->status_code,
1851 SPOE_APPCTX(appctx)->rlen, SPOE_APPCTX(appctx)->reason);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001852 goto exit;
1853 }
1854
1855 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001856 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001857 if (trash.data)
1858 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001859
Christopher Fauleta1cda022016-12-21 08:58:06 +01001860 return 0;
1861 stop:
1862 return 1;
1863 exit:
1864 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1865 return 0;
1866}
1867
1868/* I/O Handler processing messages exchanged with the agent */
1869static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001870spoe_handle_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001871{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001872 struct stream_interface *si = appctx->owner;
1873 struct spoe_agent *agent;
1874
1875 if (SPOE_APPCTX(appctx) == NULL)
1876 return;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001877
Christopher Faulet8ef75252017-02-20 22:56:03 +01001878 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
1879 agent = SPOE_APPCTX(appctx)->agent;
Christopher Fauletb067b062017-01-04 16:39:11 +01001880
Christopher Fauleta1cda022016-12-21 08:58:06 +01001881 switchstate:
1882 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1883 " - appctx-state=%s\n",
1884 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1885 __FUNCTION__, appctx, spoe_appctx_state_str[appctx->st0]);
1886
1887 switch (appctx->st0) {
1888 case SPOE_APPCTX_ST_CONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001889 if (spoe_handle_connect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001890 goto out;
1891 goto switchstate;
1892
1893 case SPOE_APPCTX_ST_CONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001894 if (spoe_handle_connecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001895 goto out;
1896 goto switchstate;
1897
1898 case SPOE_APPCTX_ST_IDLE:
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001899 _HA_ATOMIC_SUB(&agent->counters.idles, 1);
Christopher Faulet7d9f1ba2018-02-28 13:33:26 +01001900 eb32_delete(&SPOE_APPCTX(appctx)->node);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001901 if (stopping &&
Christopher Faulet24289f22017-09-25 14:48:02 +02001902 LIST_ISEMPTY(&agent->rt[tid].sending_queue) &&
Christopher Faulet42bfa462017-01-04 14:14:19 +01001903 LIST_ISEMPTY(&SPOE_APPCTX(appctx)->waiting_queue)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001904 SPOE_APPCTX(appctx)->task->expire =
1905 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001906 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001907 goto switchstate;
1908 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001909 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1910 /* fall through */
1911
1912 case SPOE_APPCTX_ST_PROCESSING:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001913 case SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY:
1914 case SPOE_APPCTX_ST_WAITING_SYNC_ACK:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001915 if (spoe_handle_processing_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001916 goto out;
1917 goto switchstate;
1918
1919 case SPOE_APPCTX_ST_DISCONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001920 if (spoe_handle_disconnect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001921 goto out;
1922 goto switchstate;
1923
1924 case SPOE_APPCTX_ST_DISCONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001925 if (spoe_handle_disconnecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001926 goto out;
1927 goto switchstate;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001928
1929 case SPOE_APPCTX_ST_EXIT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001930 appctx->st0 = SPOE_APPCTX_ST_END;
1931 SPOE_APPCTX(appctx)->task->expire = TICK_ETERNITY;
1932
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001933 si_shutw(si);
1934 si_shutr(si);
1935 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001936 /* fall through */
1937
1938 case SPOE_APPCTX_ST_END:
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001939 return;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001940 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001941 out:
Christopher Faulet24289f22017-09-25 14:48:02 +02001942 if (stopping)
1943 spoe_wakeup_appctx(appctx);
1944
Christopher Faulet42bfa462017-01-04 14:14:19 +01001945 if (SPOE_APPCTX(appctx)->task->expire != TICK_ETERNITY)
1946 task_queue(SPOE_APPCTX(appctx)->task);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001947}
1948
1949struct applet spoe_applet = {
1950 .obj_type = OBJ_TYPE_APPLET,
1951 .name = "<SPOE>", /* used for logging */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001952 .fct = spoe_handle_appctx,
1953 .release = spoe_release_appctx,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001954};
1955
1956/* Create a SPOE applet. On success, the created applet is returned, else
1957 * NULL. */
1958static struct appctx *
Christopher Faulet8ef75252017-02-20 22:56:03 +01001959spoe_create_appctx(struct spoe_config *conf)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001960{
1961 struct appctx *appctx;
1962 struct session *sess;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001963 struct stream *strm;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001964
Emeric Brun1138fd02017-06-19 12:38:55 +02001965 if ((appctx = appctx_new(&spoe_applet, tid_bit)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001966 goto out_error;
1967
Willy Tarreauc9ef9bc2021-03-22 21:04:50 +01001968 appctx->ctx.spoe.ptr = pool_zalloc(pool_head_spoe_appctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001969 if (SPOE_APPCTX(appctx) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001970 goto out_free_appctx;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001971
Christopher Faulet42bfa462017-01-04 14:14:19 +01001972 appctx->st0 = SPOE_APPCTX_ST_CONNECT;
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01001973 if ((SPOE_APPCTX(appctx)->task = task_new(tid_bit)) == NULL)
Christopher Faulet42bfa462017-01-04 14:14:19 +01001974 goto out_free_spoe_appctx;
1975
1976 SPOE_APPCTX(appctx)->owner = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001977 SPOE_APPCTX(appctx)->task->process = spoe_process_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001978 SPOE_APPCTX(appctx)->task->context = appctx;
1979 SPOE_APPCTX(appctx)->agent = conf->agent;
1980 SPOE_APPCTX(appctx)->version = 0;
1981 SPOE_APPCTX(appctx)->max_frame_size = conf->agent->max_frame_size;
1982 SPOE_APPCTX(appctx)->flags = 0;
Christopher Fauletb067b062017-01-04 16:39:11 +01001983 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001984 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001985 SPOE_APPCTX(appctx)->cur_fpa = 0;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001986
Willy Tarreau90f366b2021-02-20 11:49:49 +01001987 LIST_INIT(&SPOE_APPCTX(appctx)->buffer_wait.list);
Christopher Faulet4596fb72017-01-11 14:05:19 +01001988 SPOE_APPCTX(appctx)->buffer_wait.target = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001989 SPOE_APPCTX(appctx)->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001990
1991 LIST_INIT(&SPOE_APPCTX(appctx)->list);
1992 LIST_INIT(&SPOE_APPCTX(appctx)->waiting_queue);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001993
Willy Tarreau5820a362016-12-22 15:59:02 +01001994 sess = session_new(&conf->agent_fe, NULL, &appctx->obj_type);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001995 if (!sess)
1996 goto out_free_spoe;
1997
Christopher Faulet26256f82020-09-14 11:40:13 +02001998 if ((strm = stream_new(sess, &appctx->obj_type, &BUF_NULL)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001999 goto out_free_sess;
2000
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002001 stream_set_backend(strm, conf->agent->b.be);
2002
2003 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002004 si_cant_get(&strm->si[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002005 appctx_wakeup(appctx);
2006
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002007 strm->do_log = NULL;
2008 strm->res.flags |= CF_READ_DONTWAIT;
2009
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002010 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02002011 LIST_ADDQ(&conf->agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002012 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002013 _HA_ATOMIC_ADD(&conf->agent->counters.applets, 1);
Emeric Brun5f77fef2017-05-29 15:26:51 +02002014
Emeric Brunc60def82017-09-27 14:59:38 +02002015 task_wakeup(SPOE_APPCTX(appctx)->task, TASK_WOKEN_INIT);
Willy Tarreau87787ac2017-08-28 16:22:54 +02002016 task_wakeup(strm->task, TASK_WOKEN_INIT);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002017 return appctx;
2018
2019 /* Error unrolling */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002020 out_free_sess:
2021 session_free(sess);
2022 out_free_spoe:
Olivier Houchard3f795f72019-04-17 22:51:06 +02002023 task_destroy(SPOE_APPCTX(appctx)->task);
Christopher Faulet42bfa462017-01-04 14:14:19 +01002024 out_free_spoe_appctx:
Willy Tarreaubafbe012017-11-24 17:34:44 +01002025 pool_free(pool_head_spoe_appctx, SPOE_APPCTX(appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002026 out_free_appctx:
2027 appctx_free(appctx);
2028 out_error:
2029 return NULL;
2030}
2031
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002032static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002033spoe_queue_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002034{
2035 struct spoe_config *conf = FLT_CONF(ctx->filter);
2036 struct spoe_agent *agent = conf->agent;
2037 struct appctx *appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002038 struct spoe_appctx *spoe_appctx;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002039
Christopher Fauleta1cda022016-12-21 08:58:06 +01002040 /* Check if we need to create a new SPOE applet or not. */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002041 if (!eb_is_empty(&agent->rt[tid].idle_applets) &&
Christopher Fauleteccfa612020-06-22 15:32:14 +02002042 (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 +01002043 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002044
2045 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauleta1cda022016-12-21 08:58:06 +01002046 " - try to create new SPOE appctx\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002047 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
2048 ctx->strm);
2049
Christopher Fauleta1cda022016-12-21 08:58:06 +01002050 /* Do not try to create a new applet if there is no server up for the
2051 * agent's backend. */
2052 if (!agent->b.be->srv_act && !agent->b.be->srv_bck) {
2053 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2054 " - cannot create SPOE appctx: no server up\n",
2055 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2056 __FUNCTION__, ctx->strm);
2057 goto end;
2058 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002059
Christopher Fauleta1cda022016-12-21 08:58:06 +01002060 /* Do not try to create a new applet if we have reached the maximum of
2061 * connection per seconds */
Christopher Faulet48026722016-11-16 15:01:12 +01002062 if (agent->cps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002063 if (!freq_ctr_remain(&agent->rt[tid].conn_per_sec, agent->cps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002064 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2065 " - cannot create SPOE appctx: max CPS reached\n",
2066 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2067 __FUNCTION__, ctx->strm);
2068 goto end;
2069 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002070 }
2071
Christopher Faulet8ef75252017-02-20 22:56:03 +01002072 appctx = spoe_create_appctx(conf);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002073 if (appctx == NULL) {
2074 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2075 " - failed to create SPOE appctx\n",
2076 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2077 __FUNCTION__, ctx->strm);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02002078 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01002079 "SPOE: [%s] failed to create SPOE applet\n",
2080 agent->id);
2081
Christopher Fauleta1cda022016-12-21 08:58:06 +01002082 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002083 }
2084
Christopher Fauleta1cda022016-12-21 08:58:06 +01002085 /* Increase the per-process number of cumulated connections */
2086 if (agent->cps_max > 0)
Christopher Faulet24289f22017-09-25 14:48:02 +02002087 update_freq_ctr(&agent->rt[tid].conn_per_sec, 1);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002088
Christopher Fauleta1cda022016-12-21 08:58:06 +01002089 end:
2090 /* The only reason to return an error is when there is no applet */
Christopher Faulet24289f22017-09-25 14:48:02 +02002091 if (LIST_ISEMPTY(&agent->rt[tid].applets)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002092 ctx->status_code = SPOE_CTX_ERR_RES;
2093 return -1;
2094 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002095
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002096 /* Add the SPOE context in the sending queue if the stream has no applet
2097 * already assigned and wakeup all idle applets. Otherwise, don't queue
2098 * it. */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002099 _HA_ATOMIC_ADD(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002100 spoe_update_stat_time(&ctx->stats.tv_request, &ctx->stats.t_request);
2101 ctx->stats.tv_queue = now;
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002102 if (ctx->spoe_appctx)
2103 return 1;
2104 LIST_ADDQ(&agent->rt[tid].sending_queue, &ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002105
2106 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002107 " - Add stream in sending queue"
Christopher Faulet68db0232018-04-06 11:34:12 +02002108 " - applets=%u - idles=%u - processing=%u\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002109 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
Christopher Faulet68db0232018-04-06 11:34:12 +02002110 ctx->strm, agent->counters.applets, agent->counters.idles,
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002111 agent->rt[tid].processing);
Christopher Fauletf7a30922016-11-10 15:04:51 +01002112
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002113 /* Finally try to wakeup an IDLE applet. */
2114 if (!eb_is_empty(&agent->rt[tid].idle_applets)) {
2115 struct eb32_node *node;
2116
2117 node = eb32_first(&agent->rt[tid].idle_applets);
2118 spoe_appctx = eb32_entry(node, struct spoe_appctx, node);
2119 if (node && spoe_appctx) {
2120 eb32_delete(&spoe_appctx->node);
2121 spoe_appctx->node.key++;
2122 eb32_insert(&agent->rt[tid].idle_applets, &spoe_appctx->node);
2123 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002124 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002125 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002126 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002127}
2128
2129/***************************************************************************
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002130 * Functions that encode SPOE messages
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002131 **************************************************************************/
Christopher Faulet10e37672017-09-21 16:38:22 +02002132/* Encode a SPOE message. Info in <ctx->frag_ctx>, if any, are used to handle
2133 * fragmented_content. If the next message can be processed, it returns 0. If
2134 * the message is too big, it returns -1.*/
2135static int
2136spoe_encode_message(struct stream *s, struct spoe_context *ctx,
2137 struct spoe_message *msg, int dir,
2138 char **buf, char *end)
2139{
2140 struct sample *smp;
2141 struct spoe_arg *arg;
2142 int ret;
2143
2144 if (msg->cond) {
2145 ret = acl_exec_cond(msg->cond, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2146 ret = acl_pass(ret);
2147 if (msg->cond->pol == ACL_COND_UNLESS)
2148 ret = !ret;
2149
2150 /* the rule does not match */
2151 if (!ret)
2152 goto next;
2153 }
2154
2155 /* Resume encoding of a SPOE argument */
2156 if (ctx->frag_ctx.curarg != NULL) {
2157 arg = ctx->frag_ctx.curarg;
2158 goto encode_argument;
2159 }
2160
2161 if (ctx->frag_ctx.curoff != UINT_MAX)
2162 goto encode_msg_payload;
2163
2164 /* Check if there is enough space for the message name and the
2165 * number of arguments. It implies <msg->id_len> is encoded on 2
2166 * bytes, at most (< 2288). */
2167 if (*buf + 2 + msg->id_len + 1 > end)
2168 goto too_big;
2169
2170 /* Encode the message name */
2171 if (spoe_encode_buffer(msg->id, msg->id_len, buf, end) == -1)
2172 goto too_big;
2173
2174 /* Set the number of arguments for this message */
2175 **buf = msg->nargs;
2176 (*buf)++;
2177
2178 ctx->frag_ctx.curoff = 0;
2179 encode_msg_payload:
2180
2181 /* Loop on arguments */
2182 list_for_each_entry(arg, &msg->args, list) {
2183 ctx->frag_ctx.curarg = arg;
2184 ctx->frag_ctx.curoff = UINT_MAX;
Kevin Zhuf7f54282019-04-26 14:00:01 +08002185 ctx->frag_ctx.curlen = 0;
Christopher Faulet10e37672017-09-21 16:38:22 +02002186
2187 encode_argument:
2188 if (ctx->frag_ctx.curoff != UINT_MAX)
2189 goto encode_arg_value;
2190
Joseph Herlantf7f60312018-11-15 13:46:49 -08002191 /* Encode the argument name as a string. It can by NULL */
Christopher Faulet10e37672017-09-21 16:38:22 +02002192 if (spoe_encode_buffer(arg->name, arg->name_len, buf, end) == -1)
2193 goto too_big;
2194
2195 ctx->frag_ctx.curoff = 0;
2196 encode_arg_value:
2197
Joseph Herlantf7f60312018-11-15 13:46:49 -08002198 /* Fetch the argument value */
Christopher Faulet10e37672017-09-21 16:38:22 +02002199 smp = sample_process(s->be, s->sess, s, dir|SMP_OPT_FINAL, arg->expr, NULL);
Christopher Faulet3b1d0042019-05-06 09:53:10 +02002200 if (smp) {
2201 smp->ctx.a[0] = &ctx->frag_ctx.curlen;
2202 smp->ctx.a[1] = &ctx->frag_ctx.curoff;
2203 }
Christopher Faulet85db3212019-04-26 14:30:15 +02002204 ret = spoe_encode_data(smp, buf, end);
Christopher Faulet10e37672017-09-21 16:38:22 +02002205 if (ret == -1 || ctx->frag_ctx.curoff)
2206 goto too_big;
2207 }
2208
2209 next:
2210 return 0;
2211
2212 too_big:
2213 return -1;
2214}
2215
Christopher Fauletc718b822017-09-21 16:50:56 +02002216/* Encode list of SPOE messages. Info in <ctx->frag_ctx>, if any, are used to
2217 * handle fragmented content. On success it returns 1. If an error occurred, -1
2218 * is returned. If nothing has been encoded, it returns 0 (this is only possible
2219 * for unfragmented payload). */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002220static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002221spoe_encode_messages(struct stream *s, struct spoe_context *ctx,
Christopher Fauletc718b822017-09-21 16:50:56 +02002222 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002223{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002224 struct spoe_config *conf = FLT_CONF(ctx->filter);
2225 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002226 struct spoe_message *msg;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002227 char *p, *end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002228
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002229 p = b_head(&ctx->buffer);
Christopher Faulet24289f22017-09-25 14:48:02 +02002230 end = p + agent->rt[tid].frame_size - FRAME_HDR_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002231
Christopher Fauletc718b822017-09-21 16:50:56 +02002232 if (type == SPOE_MSGS_BY_EVENT) { /* Loop on messages by event */
2233 /* Resume encoding of a SPOE message */
2234 if (ctx->frag_ctx.curmsg != NULL) {
2235 msg = ctx->frag_ctx.curmsg;
2236 goto encode_evt_message;
2237 }
2238
2239 list_for_each_entry(msg, messages, by_evt) {
2240 ctx->frag_ctx.curmsg = msg;
2241 ctx->frag_ctx.curarg = NULL;
2242 ctx->frag_ctx.curoff = UINT_MAX;
2243
2244 encode_evt_message:
2245 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2246 goto too_big;
2247 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002248 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002249 else if (type == SPOE_MSGS_BY_GROUP) { /* Loop on messages by group */
2250 /* Resume encoding of a SPOE message */
2251 if (ctx->frag_ctx.curmsg != NULL) {
2252 msg = ctx->frag_ctx.curmsg;
2253 goto encode_grp_message;
2254 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002255
Christopher Fauletc718b822017-09-21 16:50:56 +02002256 list_for_each_entry(msg, messages, by_grp) {
2257 ctx->frag_ctx.curmsg = msg;
2258 ctx->frag_ctx.curarg = NULL;
2259 ctx->frag_ctx.curoff = UINT_MAX;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002260
Christopher Fauletc718b822017-09-21 16:50:56 +02002261 encode_grp_message:
2262 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2263 goto too_big;
2264 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002265 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002266 else
2267 goto skip;
2268
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002269
Christopher Faulet57583e42017-09-04 15:41:09 +02002270 /* nothing has been encoded for an unfragmented payload */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002271 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) && p == b_head(&ctx->buffer))
Christopher Faulet57583e42017-09-04 15:41:09 +02002272 goto skip;
2273
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002274 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002275 " - encode %s messages - spoe_appctx=%p"
2276 "- max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002277 (int)now.tv_sec, (int)now.tv_usec,
2278 agent->id, __FUNCTION__, s,
2279 ((ctx->flags & SPOE_CTX_FL_FRAGMENTED) ? "last fragment of" : "unfragmented"),
Christopher Fauletfce747b2018-01-24 15:59:32 +01002280 ctx->spoe_appctx, (agent->rt[tid].frame_size - FRAME_HDR_SIZE),
Christopher Faulet45073512018-07-20 10:16:29 +02002281 p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002282
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002283 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002284 ctx->frag_ctx.curmsg = NULL;
2285 ctx->frag_ctx.curarg = NULL;
2286 ctx->frag_ctx.curoff = 0;
2287 ctx->frag_ctx.flags = SPOE_FRM_FL_FIN;
Christopher Faulet57583e42017-09-04 15:41:09 +02002288
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002289 return 1;
2290
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002291 too_big:
Christopher Fauleta715ea82019-04-10 14:21:51 +02002292 /* Return an error if fragmentation is unsupported or if nothing has
2293 * been encoded because its too big and not splittable. */
2294 if (!(agent->flags & SPOE_FL_SND_FRAGMENTATION) || p == b_head(&ctx->buffer)) {
Christopher Fauletcecd8522017-02-24 22:11:21 +01002295 ctx->status_code = SPOE_CTX_ERR_TOO_BIG;
2296 return -1;
2297 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002298
2299 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002300 " - encode fragmented messages - spoe_appctx=%p"
2301 " - curmsg=%p - curarg=%p - curoff=%u"
2302 " - max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002303 (int)now.tv_sec, (int)now.tv_usec,
Christopher Fauletfce747b2018-01-24 15:59:32 +01002304 agent->id, __FUNCTION__, s, ctx->spoe_appctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002305 ctx->frag_ctx.curmsg, ctx->frag_ctx.curarg, ctx->frag_ctx.curoff,
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002306 (agent->rt[tid].frame_size - FRAME_HDR_SIZE), p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002307
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002308 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002309 ctx->flags |= SPOE_CTX_FL_FRAGMENTED;
2310 ctx->frag_ctx.flags &= ~SPOE_FRM_FL_FIN;
2311 return 1;
Christopher Faulet57583e42017-09-04 15:41:09 +02002312
2313 skip:
2314 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2315 " - skip the frame because nothing has been encoded\n",
2316 (int)now.tv_sec, (int)now.tv_usec,
2317 agent->id, __FUNCTION__, s);
2318 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002319}
2320
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002321
2322/***************************************************************************
2323 * Functions that handle SPOE actions
2324 **************************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002325/* Helper function to set a variable */
2326static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002327spoe_set_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002328 struct sample *smp)
2329{
2330 struct spoe_config *conf = FLT_CONF(ctx->filter);
2331 struct spoe_agent *agent = conf->agent;
2332 char varname[64];
2333
2334 memset(varname, 0, sizeof(varname));
2335 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2336 scope, agent->var_pfx, len, name);
Etienne Carriereaec89892017-12-14 09:36:40 +00002337 if (agent->flags & SPOE_FL_FORCE_SET_VAR)
2338 vars_set_by_name(varname, len, smp);
2339 else
2340 vars_set_by_name_ifexist(varname, len, smp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002341}
2342
2343/* Helper function to unset a variable */
2344static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002345spoe_unset_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002346 struct sample *smp)
2347{
2348 struct spoe_config *conf = FLT_CONF(ctx->filter);
2349 struct spoe_agent *agent = conf->agent;
2350 char varname[64];
2351
2352 memset(varname, 0, sizeof(varname));
2353 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2354 scope, agent->var_pfx, len, name);
2355 vars_unset_by_name_ifexist(varname, len, smp);
2356}
2357
2358
Christopher Faulet8ef75252017-02-20 22:56:03 +01002359static inline int
2360spoe_decode_action_set_var(struct stream *s, struct spoe_context *ctx,
2361 char **buf, char *end, int dir)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002362{
Christopher Faulet8ef75252017-02-20 22:56:03 +01002363 char *str, *scope, *p = *buf;
2364 struct sample smp;
2365 uint64_t sz;
2366 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002367
Christopher Faulet8ef75252017-02-20 22:56:03 +01002368 if (p + 2 >= end)
2369 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002370
Christopher Faulet8ef75252017-02-20 22:56:03 +01002371 /* SET-VAR requires 3 arguments */
2372 if (*p++ != 3)
2373 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002374
Christopher Faulet8ef75252017-02-20 22:56:03 +01002375 switch (*p++) {
2376 case SPOE_SCOPE_PROC: scope = "proc"; break;
2377 case SPOE_SCOPE_SESS: scope = "sess"; break;
2378 case SPOE_SCOPE_TXN : scope = "txn"; break;
2379 case SPOE_SCOPE_REQ : scope = "req"; break;
2380 case SPOE_SCOPE_RES : scope = "res"; break;
2381 default: goto skip;
2382 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002383
Christopher Faulet8ef75252017-02-20 22:56:03 +01002384 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2385 goto skip;
2386 memset(&smp, 0, sizeof(smp));
2387 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002388
Christopher Faulet8ef75252017-02-20 22:56:03 +01002389 if (spoe_decode_data(&p, end, &smp) == -1)
2390 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002391
Christopher Faulet8ef75252017-02-20 22:56:03 +01002392 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2393 " - set-var '%s.%s.%.*s'\n",
2394 (int)now.tv_sec, (int)now.tv_usec,
2395 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2396 __FUNCTION__, s, scope,
2397 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2398 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002399
Christopher Faulet2469eba2020-10-15 16:08:30 +02002400 if (smp.data.type == SMP_T_ANY)
2401 spoe_unset_var(ctx, scope, str, sz, &smp);
2402 else
2403 spoe_set_var(ctx, scope, str, sz, &smp);
Christopher Fauletb5cff602016-11-24 14:53:22 +01002404
Christopher Faulet8ef75252017-02-20 22:56:03 +01002405 ret = (p - *buf);
2406 *buf = p;
2407 return ret;
2408 skip:
2409 return 0;
2410}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002411
Christopher Faulet8ef75252017-02-20 22:56:03 +01002412static inline int
2413spoe_decode_action_unset_var(struct stream *s, struct spoe_context *ctx,
2414 char **buf, char *end, int dir)
2415{
2416 char *str, *scope, *p = *buf;
2417 struct sample smp;
2418 uint64_t sz;
2419 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002420
Christopher Faulet8ef75252017-02-20 22:56:03 +01002421 if (p + 2 >= end)
2422 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002423
Christopher Faulet8ef75252017-02-20 22:56:03 +01002424 /* UNSET-VAR requires 2 arguments */
2425 if (*p++ != 2)
2426 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002427
Christopher Faulet8ef75252017-02-20 22:56:03 +01002428 switch (*p++) {
2429 case SPOE_SCOPE_PROC: scope = "proc"; break;
2430 case SPOE_SCOPE_SESS: scope = "sess"; break;
2431 case SPOE_SCOPE_TXN : scope = "txn"; break;
2432 case SPOE_SCOPE_REQ : scope = "req"; break;
2433 case SPOE_SCOPE_RES : scope = "res"; break;
2434 default: goto skip;
2435 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002436
Christopher Faulet8ef75252017-02-20 22:56:03 +01002437 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2438 goto skip;
2439 memset(&smp, 0, sizeof(smp));
2440 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002441
Christopher Faulet8ef75252017-02-20 22:56:03 +01002442 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2443 " - unset-var '%s.%s.%.*s'\n",
2444 (int)now.tv_sec, (int)now.tv_usec,
2445 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2446 __FUNCTION__, s, scope,
2447 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2448 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002449
Christopher Faulet8ef75252017-02-20 22:56:03 +01002450 spoe_unset_var(ctx, scope, str, sz, &smp);
2451
2452 ret = (p - *buf);
2453 *buf = p;
2454 return ret;
2455 skip:
2456 return 0;
2457}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002458
Christopher Faulet8ef75252017-02-20 22:56:03 +01002459/* Process SPOE actions for a specific event. It returns 1 on success. If an
2460 * error occurred, 0 is returned. */
2461static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002462spoe_process_actions(struct stream *s, struct spoe_context *ctx, int dir)
Christopher Faulet8ef75252017-02-20 22:56:03 +01002463{
2464 char *p, *end;
2465 int ret;
2466
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002467 p = b_head(&ctx->buffer);
2468 end = p + b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002469
2470 while (p < end) {
2471 enum spoe_action_type type;
2472
2473 type = *p++;
2474 switch (type) {
2475 case SPOE_ACT_T_SET_VAR:
2476 ret = spoe_decode_action_set_var(s, ctx, &p, end, dir);
2477 if (!ret)
2478 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002479 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002480
Christopher Faulet8ef75252017-02-20 22:56:03 +01002481 case SPOE_ACT_T_UNSET_VAR:
2482 ret = spoe_decode_action_unset_var(s, ctx, &p, end, dir);
2483 if (!ret)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002484 goto skip;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002485 break;
2486
2487 default:
2488 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002489 }
2490 }
2491
2492 return 1;
2493 skip:
2494 return 0;
2495}
2496
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002497/***************************************************************************
2498 * Functions that process SPOE events
2499 **************************************************************************/
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002500static void
2501spoe_update_stats(struct stream *s, struct spoe_agent *agent,
2502 struct spoe_context *ctx, int dir)
2503{
2504 if (!tv_iszero(&ctx->stats.tv_start)) {
2505 spoe_update_stat_time(&ctx->stats.tv_start, &ctx->stats.t_process);
2506 ctx->stats.t_total += ctx->stats.t_process;
2507 tv_zero(&ctx->stats.tv_request);
2508 tv_zero(&ctx->stats.tv_queue);
2509 tv_zero(&ctx->stats.tv_wait);
2510 tv_zero(&ctx->stats.tv_response);
2511 }
2512
2513 if (agent->var_t_process) {
2514 struct sample smp;
2515
2516 memset(&smp, 0, sizeof(smp));
2517 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2518 smp.data.u.sint = ctx->stats.t_process;
2519 smp.data.type = SMP_T_SINT;
2520
2521 spoe_set_var(ctx, "txn", agent->var_t_process,
2522 strlen(agent->var_t_process), &smp);
2523 }
2524
2525 if (agent->var_t_total) {
2526 struct sample smp;
2527
2528 memset(&smp, 0, sizeof(smp));
2529 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2530 smp.data.u.sint = ctx->stats.t_total;
2531 smp.data.type = SMP_T_SINT;
2532
2533 spoe_set_var(ctx, "txn", agent->var_t_total,
2534 strlen(agent->var_t_total), &smp);
2535 }
2536}
2537
2538static void
2539spoe_handle_processing_error(struct stream *s, struct spoe_agent *agent,
2540 struct spoe_context *ctx, int dir)
2541{
2542 if (agent->eps_max > 0)
2543 update_freq_ctr(&agent->rt[tid].err_per_sec, 1);
2544
2545 if (agent->var_on_error) {
2546 struct sample smp;
2547
2548 memset(&smp, 0, sizeof(smp));
2549 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2550 smp.data.u.sint = ctx->status_code;
2551 smp.data.type = SMP_T_BOOL;
2552
2553 spoe_set_var(ctx, "txn", agent->var_on_error,
2554 strlen(agent->var_on_error), &smp);
2555 }
2556
2557 ctx->state = ((agent->flags & SPOE_FL_CONT_ON_ERR)
2558 ? SPOE_CTX_ST_READY
2559 : SPOE_CTX_ST_NONE);
2560}
2561
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002562static inline int
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002563spoe_start_processing(struct spoe_agent *agent, struct spoe_context *ctx, int dir)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002564{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002565 /* If a process is already started for this SPOE context, retry
2566 * later. */
2567 if (ctx->flags & SPOE_CTX_FL_PROCESS)
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002568 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002569
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002570 agent->rt[tid].processing++;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002571 ctx->stats.tv_start = now;
2572 ctx->stats.tv_request = now;
2573 ctx->stats.t_request = -1;
2574 ctx->stats.t_queue = -1;
2575 ctx->stats.t_waiting = -1;
2576 ctx->stats.t_response = -1;
2577 ctx->stats.t_process = -1;
2578
2579 ctx->status_code = 0;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002580
Christopher Fauleta1cda022016-12-21 08:58:06 +01002581 /* Set the right flag to prevent request and response processing
2582 * in same time. */
2583 ctx->flags |= ((dir == SMP_OPT_DIR_REQ)
2584 ? SPOE_CTX_FL_REQ_PROCESS
2585 : SPOE_CTX_FL_RSP_PROCESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002586 return 1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002587}
2588
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002589static inline void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002590spoe_stop_processing(struct spoe_agent *agent, struct spoe_context *ctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002591{
Christopher Fauletfce747b2018-01-24 15:59:32 +01002592 struct spoe_appctx *sa = ctx->spoe_appctx;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002593
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002594 if (!(ctx->flags & SPOE_CTX_FL_PROCESS))
2595 return;
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002596 _HA_ATOMIC_ADD(&agent->counters.nb_processed, 1);
Christopher Faulet879dca92018-03-23 11:53:24 +01002597 if (sa) {
2598 if (sa->frag_ctx.ctx == ctx) {
2599 sa->frag_ctx.ctx = NULL;
2600 spoe_wakeup_appctx(sa->owner);
2601 }
2602 else
2603 sa->cur_fpa--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002604 }
2605
Christopher Fauleta1cda022016-12-21 08:58:06 +01002606 /* Reset the flag to allow next processing */
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002607 agent->rt[tid].processing--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002608 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002609
2610 /* Reset processing timer */
2611 ctx->process_exp = TICK_ETERNITY;
2612
Christopher Faulet8ef75252017-02-20 22:56:03 +01002613 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002614
Christopher Fauletfce747b2018-01-24 15:59:32 +01002615 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002616 ctx->frag_ctx.curmsg = NULL;
2617 ctx->frag_ctx.curarg = NULL;
2618 ctx->frag_ctx.curoff = 0;
2619 ctx->frag_ctx.flags = 0;
2620
Christopher Fauleta1cda022016-12-21 08:58:06 +01002621 if (!LIST_ISEMPTY(&ctx->list)) {
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002622 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS)
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002623 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002624 else
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002625 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002626
Christopher Fauleta1cda022016-12-21 08:58:06 +01002627 LIST_DEL(&ctx->list);
2628 LIST_INIT(&ctx->list);
2629 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002630}
2631
Christopher Faulet58d03682017-09-21 16:57:24 +02002632/* Process a list of SPOE messages. First, this functions will process messages
2633 * and send them to an agent in a NOTIFY frame. Then, it will wait a ACK frame
2634 * to process corresponding actions. During all the processing, it returns 0
2635 * and it returns 1 when the processing is finished. If an error occurred, -1
2636 * is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002637static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002638spoe_process_messages(struct stream *s, struct spoe_context *ctx,
2639 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002640{
Christopher Fauletf7a30922016-11-10 15:04:51 +01002641 struct spoe_config *conf = FLT_CONF(ctx->filter);
2642 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002643 int ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002644
2645 if (ctx->state == SPOE_CTX_ST_ERROR)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002646 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002647
2648 if (tick_is_expired(ctx->process_exp, now_ms) && ctx->state != SPOE_CTX_ST_DONE) {
2649 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002650 " - failed to process messages: timeout\n",
Christopher Fauletf7a30922016-11-10 15:04:51 +01002651 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002652 agent->id, __FUNCTION__, s);
Christopher Fauletb067b062017-01-04 16:39:11 +01002653 ctx->status_code = SPOE_CTX_ERR_TOUT;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002654 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002655 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002656
2657 if (ctx->state == SPOE_CTX_ST_READY) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002658 if (agent->eps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002659 if (!freq_ctr_remain(&agent->rt[tid].err_per_sec, agent->eps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002660 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002661 " - skip processing of messages: max EPS reached\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002662 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002663 agent->id, __FUNCTION__, s);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002664 goto skip;
2665 }
2666 }
2667
Christopher Fauletf7a30922016-11-10 15:04:51 +01002668 if (!tick_isset(ctx->process_exp)) {
2669 ctx->process_exp = tick_add_ifset(now_ms, agent->timeout.processing);
2670 s->task->expire = tick_first((tick_is_expired(s->task->expire, now_ms) ? 0 : s->task->expire),
2671 ctx->process_exp);
2672 }
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002673 ret = spoe_start_processing(agent, ctx, dir);
Christopher Fauletb067b062017-01-04 16:39:11 +01002674 if (!ret)
2675 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002676
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002677 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002678 /* fall through */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002679 }
2680
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002681 if (ctx->state == SPOE_CTX_ST_ENCODING_MSGS) {
Christopher Faulet63263e52019-04-10 14:47:18 +02002682 if (tv_iszero(&ctx->stats.tv_request))
2683 ctx->stats.tv_request = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002684 if (!spoe_acquire_buffer(&ctx->buffer, &ctx->buffer_wait))
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002685 goto out;
Christopher Faulet58d03682017-09-21 16:57:24 +02002686 ret = spoe_encode_messages(s, ctx, messages, dir, type);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002687 if (ret < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002688 goto end;
Christopher Faulet57583e42017-09-04 15:41:09 +02002689 if (!ret)
2690 goto skip;
Christopher Faulet333694d2018-01-12 10:45:47 +01002691 if (spoe_queue_context(ctx) < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002692 goto end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002693 ctx->state = SPOE_CTX_ST_SENDING_MSGS;
2694 }
2695
2696 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS) {
Christopher Fauletfce747b2018-01-24 15:59:32 +01002697 if (ctx->spoe_appctx)
2698 spoe_wakeup_appctx(ctx->spoe_appctx->owner);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002699 ret = 0;
2700 goto out;
2701 }
2702
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002703 if (ctx->state == SPOE_CTX_ST_WAITING_ACK) {
2704 ret = 0;
2705 goto out;
2706 }
2707
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002708 if (ctx->state == SPOE_CTX_ST_DONE) {
Christopher Faulet58d03682017-09-21 16:57:24 +02002709 spoe_process_actions(s, ctx, dir);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002710 ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002711 ctx->frame_id++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002712 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002713 spoe_update_stat_time(&ctx->stats.tv_response, &ctx->stats.t_response);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002714 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002715 }
2716
2717 out:
2718 return ret;
2719
Christopher Fauleta1cda022016-12-21 08:58:06 +01002720 skip:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002721 tv_zero(&ctx->stats.tv_start);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002722 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002723 spoe_stop_processing(agent, ctx);
2724 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002725
Christopher Fauleta1cda022016-12-21 08:58:06 +01002726 end:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002727 spoe_update_stats(s, agent, ctx, dir);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002728 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002729 if (ctx->status_code) {
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002730 _HA_ATOMIC_ADD(&agent->counters.nb_errors, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002731 spoe_handle_processing_error(s, agent, ctx, dir);
2732 ret = 1;
2733 }
Christopher Faulet58d03682017-09-21 16:57:24 +02002734 return ret;
2735}
2736
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002737/* Process a SPOE group, ie the list of messages attached to the group <grp>.
2738 * See spoe_process_message for details. */
2739static int
2740spoe_process_group(struct stream *s, struct spoe_context *ctx,
2741 struct spoe_group *group, int dir)
2742{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002743 struct spoe_config *conf = FLT_CONF(ctx->filter);
2744 struct spoe_agent *agent = conf->agent;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002745 int ret;
2746
2747 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2748 " - ctx-state=%s - Process messages for group=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002749 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002750 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2751 group->id);
2752
2753 if (LIST_ISEMPTY(&group->messages))
2754 return 1;
2755
2756 ret = spoe_process_messages(s, ctx, &group->messages, dir, SPOE_MSGS_BY_GROUP);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002757 if (ret && ctx->stats.t_process != -1) {
2758 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002759 " - <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 +01002760 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002761 __FUNCTION__, s, group->id, s->uniq_id, ctx->status_code,
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002762 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002763 ctx->stats.t_response, ctx->stats.t_process,
2764 agent->counters.idles, agent->counters.applets,
2765 agent->counters.nb_sending, agent->counters.nb_waiting,
2766 agent->counters.nb_errors, agent->counters.nb_processed,
2767 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2768 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2769 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2770 "SPOE: [%s] <GROUP:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2771 agent->id, group->id, s->uniq_id, ctx->status_code,
2772 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2773 ctx->stats.t_response, ctx->stats.t_process,
2774 agent->counters.idles, agent->counters.applets,
2775 agent->counters.nb_sending, agent->counters.nb_waiting,
2776 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002777 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002778 return ret;
2779}
2780
Christopher Faulet58d03682017-09-21 16:57:24 +02002781/* Process a SPOE event, ie the list of messages attached to the event <ev>.
2782 * See spoe_process_message for details. */
2783static int
2784spoe_process_event(struct stream *s, struct spoe_context *ctx,
2785 enum spoe_event ev)
2786{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002787 struct spoe_config *conf = FLT_CONF(ctx->filter);
2788 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002789 int dir, ret;
2790
2791 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002792 " - ctx-state=%s - Process messages for event=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002793 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet58d03682017-09-21 16:57:24 +02002794 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2795 spoe_event_str[ev]);
2796
2797 dir = ((ev < SPOE_EV_ON_SERVER_SESS) ? SMP_OPT_DIR_REQ : SMP_OPT_DIR_RES);
2798
2799 if (LIST_ISEMPTY(&(ctx->events[ev])))
2800 return 1;
2801
2802 ret = spoe_process_messages(s, ctx, &(ctx->events[ev]), dir, SPOE_MSGS_BY_EVENT);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002803 if (ret && ctx->stats.t_process != -1) {
2804 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002805 " - <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 +01002806 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2807 __FUNCTION__, s, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2808 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002809 ctx->stats.t_response, ctx->stats.t_process,
2810 agent->counters.idles, agent->counters.applets,
2811 agent->counters.nb_sending, agent->counters.nb_waiting,
2812 agent->counters.nb_errors, agent->counters.nb_processed,
2813 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2814 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2815 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2816 "SPOE: [%s] <EVENT:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2817 agent->id, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2818 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2819 ctx->stats.t_response, ctx->stats.t_process,
2820 agent->counters.idles, agent->counters.applets,
2821 agent->counters.nb_sending, agent->counters.nb_waiting,
2822 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002823 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002824 return ret;
2825}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002826
2827/***************************************************************************
2828 * Functions that create/destroy SPOE contexts
2829 **************************************************************************/
Christopher Fauleta1cda022016-12-21 08:58:06 +01002830static int
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002831spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002832{
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002833 if (buf->size)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002834 return 1;
2835
Willy Tarreau90f366b2021-02-20 11:49:49 +01002836 if (LIST_ADDED(&buffer_wait->list))
2837 LIST_DEL_INIT(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002838
Willy Tarreaud68d4f12021-03-22 14:44:31 +01002839 if (b_alloc(buf))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002840 return 1;
2841
Willy Tarreau90f366b2021-02-20 11:49:49 +01002842 LIST_ADDQ(&ti->buffer_wq, &buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002843 return 0;
2844}
2845
2846static void
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002847spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002848{
Willy Tarreau90f366b2021-02-20 11:49:49 +01002849 if (LIST_ADDED(&buffer_wait->list))
2850 LIST_DEL_INIT(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002851
2852 /* Release the buffer if needed */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002853 if (buf->size) {
Christopher Faulet4596fb72017-01-11 14:05:19 +01002854 b_free(buf);
Willy Tarreau4d77bbf2021-02-20 12:02:46 +01002855 offer_buffers(buffer_wait->target, 1);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002856 }
2857}
2858
Christopher Faulet4596fb72017-01-11 14:05:19 +01002859static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002860spoe_wakeup_context(struct spoe_context *ctx)
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002861{
2862 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
2863 return 1;
2864}
2865
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002866static struct spoe_context *
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002867spoe_create_context(struct stream *s, struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002868{
2869 struct spoe_config *conf = FLT_CONF(filter);
2870 struct spoe_context *ctx;
2871
Willy Tarreauc9ef9bc2021-03-22 21:04:50 +01002872 ctx = pool_zalloc(pool_head_spoe_ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002873 if (ctx == NULL) {
2874 return NULL;
2875 }
Christopher Fauletb067b062017-01-04 16:39:11 +01002876 ctx->filter = filter;
2877 ctx->state = SPOE_CTX_ST_NONE;
2878 ctx->status_code = SPOE_CTX_ERR_NONE;
2879 ctx->flags = 0;
Christopher Faulet11610f32017-09-21 10:23:10 +02002880 ctx->events = conf->agent->events;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02002881 ctx->groups = &conf->agent->groups;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002882 ctx->buffer = BUF_NULL;
Willy Tarreau90f366b2021-02-20 11:49:49 +01002883 LIST_INIT(&ctx->buffer_wait.list);
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002884 ctx->buffer_wait.target = ctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002885 ctx->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_context;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002886 LIST_INIT(&ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002887
Christopher Fauletf7a30922016-11-10 15:04:51 +01002888 ctx->stream_id = 0;
2889 ctx->frame_id = 1;
2890 ctx->process_exp = TICK_ETERNITY;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002891
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002892 tv_zero(&ctx->stats.tv_start);
2893 tv_zero(&ctx->stats.tv_request);
2894 tv_zero(&ctx->stats.tv_queue);
2895 tv_zero(&ctx->stats.tv_wait);
2896 tv_zero(&ctx->stats.tv_response);
2897 ctx->stats.t_request = -1;
2898 ctx->stats.t_queue = -1;
2899 ctx->stats.t_waiting = -1;
2900 ctx->stats.t_response = -1;
2901 ctx->stats.t_process = -1;
2902 ctx->stats.t_total = 0;
2903
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002904 ctx->strm = s;
2905 ctx->state = SPOE_CTX_ST_READY;
2906 filter->ctx = ctx;
2907
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002908 return ctx;
2909}
2910
2911static void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002912spoe_destroy_context(struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002913{
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002914 struct spoe_config *conf = FLT_CONF(filter);
2915 struct spoe_context *ctx = filter->ctx;
2916
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002917 if (!ctx)
2918 return;
2919
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002920 spoe_stop_processing(conf->agent, ctx);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002921 pool_free(pool_head_spoe_ctx, ctx);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002922 filter->ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002923}
2924
2925static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002926spoe_reset_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002927{
2928 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01002929 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002930
2931 tv_zero(&ctx->stats.tv_start);
2932 tv_zero(&ctx->stats.tv_request);
2933 tv_zero(&ctx->stats.tv_queue);
2934 tv_zero(&ctx->stats.tv_wait);
2935 tv_zero(&ctx->stats.tv_response);
2936 ctx->stats.t_request = -1;
2937 ctx->stats.t_queue = -1;
2938 ctx->stats.t_waiting = -1;
2939 ctx->stats.t_response = -1;
2940 ctx->stats.t_process = -1;
2941 ctx->stats.t_total = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002942}
2943
2944
2945/***************************************************************************
2946 * Hooks that manage the filter lifecycle (init/check/deinit)
2947 **************************************************************************/
2948/* Signal handler: Do a soft stop, wakeup SPOE applet */
2949static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002950spoe_sig_stop(struct sig_handler *sh)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002951{
2952 struct proxy *p;
2953
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002954 p = proxies_list;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002955 while (p) {
2956 struct flt_conf *fconf;
2957
2958 list_for_each_entry(fconf, &p->filter_configs, list) {
Christopher Faulet3b386a32017-02-23 10:17:15 +01002959 struct spoe_config *conf;
2960 struct spoe_agent *agent;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002961 struct spoe_appctx *spoe_appctx;
Christopher Faulet24289f22017-09-25 14:48:02 +02002962 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002963
Christopher Faulet3b386a32017-02-23 10:17:15 +01002964 if (fconf->id != spoe_filter_id)
2965 continue;
2966
2967 conf = fconf->conf;
2968 agent = conf->agent;
2969
Christopher Faulet24289f22017-09-25 14:48:02 +02002970 for (i = 0; i < global.nbthread; ++i) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002971 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02002972 list_for_each_entry(spoe_appctx, &agent->rt[i].applets, list)
2973 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002974 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002975 }
2976 }
2977 p = p->next;
2978 }
2979}
2980
2981
2982/* Initialize the SPOE filter. Returns -1 on error, else 0. */
2983static int
2984spoe_init(struct proxy *px, struct flt_conf *fconf)
2985{
2986 struct spoe_config *conf = fconf->conf;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002987
Christopher Faulet7250b8f2018-03-26 17:19:01 +02002988 /* conf->agent_fe was already initialized during the config
2989 * parsing. Finish initialization. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002990 conf->agent_fe.last_change = now.tv_sec;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002991 conf->agent_fe.cap = PR_CAP_FE;
2992 conf->agent_fe.mode = PR_MODE_TCP;
2993 conf->agent_fe.maxconn = 0;
2994 conf->agent_fe.options2 |= PR_O2_INDEPSTR;
2995 conf->agent_fe.conn_retries = CONN_RETRIES;
2996 conf->agent_fe.accept = frontend_accept;
2997 conf->agent_fe.srv = NULL;
2998 conf->agent_fe.timeout.client = TICK_ETERNITY;
2999 conf->agent_fe.default_target = &spoe_applet.obj_type;
3000 conf->agent_fe.fe_req_ana = AN_REQ_SWITCHING_RULES;
3001
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003002 if (!sighandler_registered) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003003 signal_register_fct(0, spoe_sig_stop, 0);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003004 sighandler_registered = 1;
3005 }
3006
Christopher Faulet00292352019-01-09 15:05:10 +01003007 fconf->flags |= FLT_CFG_FL_HTX;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003008 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003009}
3010
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003011/* Free resources allocated by the SPOE filter. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003012static void
3013spoe_deinit(struct proxy *px, struct flt_conf *fconf)
3014{
3015 struct spoe_config *conf = fconf->conf;
3016
3017 if (conf) {
3018 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003019
Christopher Faulet8ef75252017-02-20 22:56:03 +01003020 spoe_release_agent(agent);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003021 free(conf->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003022 free(conf);
3023 }
3024 fconf->conf = NULL;
3025}
3026
3027/* Check configuration of a SPOE filter for a specified proxy.
3028 * Return 1 on error, else 0. */
3029static int
3030spoe_check(struct proxy *px, struct flt_conf *fconf)
3031{
Christopher Faulet7ee86672017-09-19 11:08:28 +02003032 struct flt_conf *f;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003033 struct spoe_config *conf = fconf->conf;
3034 struct proxy *target;
Christopher Faulet1d7d0f82021-02-19 10:56:41 +01003035 struct logsrv *logsrv;
Willy Tarreaub0769b22019-02-07 13:40:33 +01003036 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003037
Christopher Faulet7ee86672017-09-19 11:08:28 +02003038 /* Check all SPOE filters for proxy <px> to be sure all SPOE agent names
3039 * are uniq */
3040 list_for_each_entry(f, &px->filter_configs, list) {
3041 struct spoe_config *c = f->conf;
3042
3043 /* This is not an SPOE filter */
3044 if (f->id != spoe_filter_id)
3045 continue;
3046 /* This is the current SPOE filter */
3047 if (f == fconf)
3048 continue;
3049
3050 /* Check engine Id. It should be uniq */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003051 if (strcmp(conf->id, c->id) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003052 ha_alert("Proxy %s : duplicated name for SPOE engine '%s'.\n",
3053 px->id, conf->id);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003054 return 1;
3055 }
3056 }
3057
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003058 target = proxy_be_by_name(conf->agent->b.name);
3059 if (target == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003060 ha_alert("Proxy %s : unknown backend '%s' used by SPOE agent '%s'"
3061 " declared at %s:%d.\n",
3062 px->id, conf->agent->b.name, conf->agent->id,
3063 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003064 return 1;
3065 }
3066 if (target->mode != PR_MODE_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003067 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3068 " at %s:%d does not support HTTP mode.\n",
3069 px->id, target->id, conf->agent->id,
3070 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003071 return 1;
3072 }
3073
Willy Tarreau2bdcfde2019-02-05 13:37:19 +01003074 if (px->bind_proc & ~target->bind_proc) {
3075 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3076 " at %s:%d does not cover all of its processes.\n",
3077 px->id, target->id, conf->agent->id,
3078 conf->agent->conf.file, conf->agent->conf.line);
3079 return 1;
3080 }
3081
Christopher Fauletfe261552019-03-18 13:57:42 +01003082 if ((conf->agent->rt = calloc(global.nbthread, sizeof(*conf->agent->rt))) == NULL) {
Willy Tarreaub0769b22019-02-07 13:40:33 +01003083 ha_alert("Proxy %s : out of memory initializing SPOE agent '%s' declared at %s:%d.\n",
3084 px->id, conf->agent->id, conf->agent->conf.file, conf->agent->conf.line);
3085 return 1;
3086 }
3087 for (i = 0; i < global.nbthread; ++i) {
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003088 conf->agent->rt[i].engine_id = NULL;
Christopher Fauletfe261552019-03-18 13:57:42 +01003089 conf->agent->rt[i].frame_size = conf->agent->max_frame_size;
3090 conf->agent->rt[i].processing = 0;
3091 LIST_INIT(&conf->agent->rt[i].applets);
3092 LIST_INIT(&conf->agent->rt[i].sending_queue);
3093 LIST_INIT(&conf->agent->rt[i].waiting_queue);
3094 HA_SPIN_INIT(&conf->agent->rt[i].lock);
Willy Tarreaub0769b22019-02-07 13:40:33 +01003095 }
3096
Christopher Faulet1d7d0f82021-02-19 10:56:41 +01003097 list_for_each_entry(logsrv, &conf->agent_fe.logsrvs, list) {
3098 if (logsrv->type == LOG_TARGET_BUFFER) {
3099 struct sink *sink = sink_find(logsrv->ring_name);
3100
3101 if (!sink || sink->type != SINK_TYPE_BUFFER) {
3102 ha_alert("Proxy %s : log server used by SPOE agent '%s' declared"
Ilya Shipitsind7a988c2021-03-04 23:26:15 +05003103 " at %s:%d uses unknown ring named '%s'.\n",
Christopher Faulet1d7d0f82021-02-19 10:56:41 +01003104 px->id, conf->agent->id, conf->agent->conf.file,
3105 conf->agent->conf.line, logsrv->ring_name);
3106 return 1;
3107 }
3108 logsrv->sink = sink;
3109 }
3110 }
3111
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003112 ha_free(&conf->agent->b.name);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003113 conf->agent->b.be = target;
3114 return 0;
3115}
3116
Kevin Zhud87b1a52019-09-17 15:05:45 +02003117/* Initializes the SPOE filter for a proxy for a specific thread.
3118 * Returns a negative value if an error occurs. */
3119static int
3120spoe_init_per_thread(struct proxy *p, struct flt_conf *fconf)
3121{
3122 struct spoe_config *conf = fconf->conf;
3123 struct spoe_agent *agent = conf->agent;
3124
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003125 agent->rt[tid].engine_id = generate_pseudo_uuid();
3126 if (agent->rt[tid].engine_id == NULL)
3127 return -1;
Kevin Zhud87b1a52019-09-17 15:05:45 +02003128 return 0;
3129}
3130
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003131/**************************************************************************
3132 * Hooks attached to a stream
3133 *************************************************************************/
3134/* Called when a filter instance is created and attach to a stream. It creates
3135 * the context that will be used to process this stream. */
3136static int
3137spoe_start(struct stream *s, struct filter *filter)
3138{
Christopher Faulet72bcc472017-01-04 16:39:41 +01003139 struct spoe_config *conf = FLT_CONF(filter);
3140 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003141 struct spoe_context *ctx;
3142
3143 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
Christopher Faulet72bcc472017-01-04 16:39:41 +01003144 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003145 __FUNCTION__, s);
3146
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003147 if ((ctx = spoe_create_context(s, filter)) == NULL) {
Christopher Faulet72bcc472017-01-04 16:39:41 +01003148 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
3149 " - failed to create SPOE context\n",
3150 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletccbc3fd2017-09-15 11:51:18 +02003151 __FUNCTION__, s);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02003152 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01003153 "SPOE: [%s] failed to create SPOE context\n",
3154 agent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003155 return 0;
3156 }
3157
Christopher Faulet11610f32017-09-21 10:23:10 +02003158 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003159 filter->pre_analyzers |= AN_REQ_INSPECT_FE;
3160
Christopher Faulet11610f32017-09-21 10:23:10 +02003161 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003162 filter->pre_analyzers |= AN_REQ_INSPECT_BE;
3163
Christopher Faulet11610f32017-09-21 10:23:10 +02003164 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003165 filter->pre_analyzers |= AN_RES_INSPECT;
3166
Christopher Faulet11610f32017-09-21 10:23:10 +02003167 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003168 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_FE;
3169
Christopher Faulet11610f32017-09-21 10:23:10 +02003170 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003171 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_BE;
3172
Christopher Faulet11610f32017-09-21 10:23:10 +02003173 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003174 filter->pre_analyzers |= AN_RES_HTTP_PROCESS_FE;
3175
3176 return 1;
3177}
3178
3179/* Called when a filter instance is detached from a stream. It release the
3180 * attached SPOE context. */
3181static void
3182spoe_stop(struct stream *s, struct filter *filter)
3183{
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003184 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
3185 (int)now.tv_sec, (int)now.tv_usec,
3186 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3187 __FUNCTION__, s);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003188 spoe_destroy_context(filter);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003189}
3190
Christopher Fauletf7a30922016-11-10 15:04:51 +01003191
3192/*
3193 * Called when the stream is woken up because of expired timer.
3194 */
3195static void
3196spoe_check_timeouts(struct stream *s, struct filter *filter)
3197{
3198 struct spoe_context *ctx = filter->ctx;
3199
Christopher Fauletac580602018-03-20 16:09:20 +01003200 if (tick_is_expired(ctx->process_exp, now_ms))
Christopher Fauleta73e59b2016-12-09 17:30:18 +01003201 s->pending_events |= TASK_WOKEN_MSG;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003202}
3203
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003204/* Called when we are ready to filter data on a channel */
3205static int
3206spoe_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3207{
3208 struct spoe_context *ctx = filter->ctx;
3209 int ret = 1;
3210
3211 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3212 " - ctx-flags=0x%08x\n",
3213 (int)now.tv_sec, (int)now.tv_usec,
3214 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3215 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3216
Christopher Fauletb067b062017-01-04 16:39:11 +01003217 if (ctx->state == SPOE_CTX_ST_NONE)
3218 goto out;
3219
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003220 if (!(chn->flags & CF_ISRESP)) {
3221 if (filter->pre_analyzers & AN_REQ_INSPECT_FE)
3222 chn->analysers |= AN_REQ_INSPECT_FE;
3223 if (filter->pre_analyzers & AN_REQ_INSPECT_BE)
3224 chn->analysers |= AN_REQ_INSPECT_BE;
3225
3226 if (ctx->flags & SPOE_CTX_FL_CLI_CONNECTED)
3227 goto out;
3228
3229 ctx->stream_id = s->uniq_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01003230 ret = spoe_process_event(s, ctx, SPOE_EV_ON_CLIENT_SESS);
Christopher Fauletb067b062017-01-04 16:39:11 +01003231 if (!ret)
3232 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003233 ctx->flags |= SPOE_CTX_FL_CLI_CONNECTED;
3234 }
3235 else {
Miroslav Zagorac88403262020-06-19 22:17:17 +02003236 if (filter->pre_analyzers & AN_RES_INSPECT)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003237 chn->analysers |= AN_RES_INSPECT;
3238
3239 if (ctx->flags & SPOE_CTX_FL_SRV_CONNECTED)
3240 goto out;
3241
Christopher Faulet8ef75252017-02-20 22:56:03 +01003242 ret = spoe_process_event(s, ctx, SPOE_EV_ON_SERVER_SESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003243 if (!ret) {
3244 channel_dont_read(chn);
3245 channel_dont_close(chn);
Christopher Fauletb067b062017-01-04 16:39:11 +01003246 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003247 }
Christopher Fauletb067b062017-01-04 16:39:11 +01003248 ctx->flags |= SPOE_CTX_FL_SRV_CONNECTED;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003249 }
3250
3251 out:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003252 return ret;
3253}
3254
3255/* Called before a processing happens on a given channel */
3256static int
3257spoe_chn_pre_analyze(struct stream *s, struct filter *filter,
3258 struct channel *chn, unsigned an_bit)
3259{
3260 struct spoe_context *ctx = filter->ctx;
3261 int ret = 1;
3262
3263 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3264 " - ctx-flags=0x%08x - ana=0x%08x\n",
3265 (int)now.tv_sec, (int)now.tv_usec,
3266 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3267 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
3268 ctx->flags, an_bit);
3269
Christopher Fauletb067b062017-01-04 16:39:11 +01003270 if (ctx->state == SPOE_CTX_ST_NONE)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003271 goto out;
3272
3273 switch (an_bit) {
3274 case AN_REQ_INSPECT_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003275 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003276 break;
3277 case AN_REQ_INSPECT_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003278 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003279 break;
3280 case AN_RES_INSPECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003281 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003282 break;
3283 case AN_REQ_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003284 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003285 break;
3286 case AN_REQ_HTTP_PROCESS_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003287 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003288 break;
3289 case AN_RES_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003290 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003291 break;
3292 }
3293
3294 out:
Christopher Faulet9cdca972018-02-01 08:45:45 +01003295 if (!ret && (chn->flags & CF_ISRESP)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003296 channel_dont_read(chn);
3297 channel_dont_close(chn);
3298 }
3299 return ret;
3300}
3301
3302/* Called when the filtering on the channel ends. */
3303static int
3304spoe_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3305{
3306 struct spoe_context *ctx = filter->ctx;
3307
3308 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3309 " - ctx-flags=0x%08x\n",
3310 (int)now.tv_sec, (int)now.tv_usec,
3311 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3312 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3313
3314 if (!(ctx->flags & SPOE_CTX_FL_PROCESS)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003315 spoe_reset_context(ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003316 }
3317
3318 return 1;
3319}
3320
3321/********************************************************************
3322 * Functions that manage the filter initialization
3323 ********************************************************************/
3324struct flt_ops spoe_ops = {
3325 /* Manage SPOE filter, called for each filter declaration */
3326 .init = spoe_init,
3327 .deinit = spoe_deinit,
3328 .check = spoe_check,
Kevin Zhud87b1a52019-09-17 15:05:45 +02003329 .init_per_thread = spoe_init_per_thread,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003330
3331 /* Handle start/stop of SPOE */
Christopher Fauletf7a30922016-11-10 15:04:51 +01003332 .attach = spoe_start,
3333 .detach = spoe_stop,
3334 .check_timeouts = spoe_check_timeouts,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003335
3336 /* Handle channels activity */
3337 .channel_start_analyze = spoe_start_analyze,
3338 .channel_pre_analyze = spoe_chn_pre_analyze,
3339 .channel_end_analyze = spoe_end_analyze,
3340};
3341
3342
3343static int
3344cfg_parse_spoe_agent(const char *file, int linenum, char **args, int kwm)
3345{
3346 const char *err;
3347 int i, err_code = 0;
3348
3349 if ((cfg_scope == NULL && curengine != NULL) ||
3350 (cfg_scope != NULL && curengine == NULL) ||
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003351 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope) != 0))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003352 goto out;
3353
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003354 if (strcmp(args[0], "spoe-agent") == 0) { /* new spoe-agent section */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003355 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003356 ha_alert("parsing [%s:%d] : missing name for spoe-agent section.\n",
3357 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003358 err_code |= ERR_ALERT | ERR_ABORT;
3359 goto out;
3360 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003361 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3362 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003363 goto out;
3364 }
3365
3366 err = invalid_char(args[1]);
3367 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003368 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3369 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003370 err_code |= ERR_ALERT | ERR_ABORT;
3371 goto out;
3372 }
3373
3374 if (curagent != NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003375 ha_alert("parsing [%s:%d] : another spoe-agent section previously defined.\n",
3376 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003377 err_code |= ERR_ALERT | ERR_ABORT;
3378 goto out;
3379 }
3380 if ((curagent = calloc(1, sizeof(*curagent))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003381 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003382 err_code |= ERR_ALERT | ERR_ABORT;
3383 goto out;
3384 }
3385
3386 curagent->id = strdup(args[1]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003387
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003388 curagent->conf.file = strdup(file);
3389 curagent->conf.line = linenum;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003390
3391 curagent->timeout.hello = TICK_ETERNITY;
3392 curagent->timeout.idle = TICK_ETERNITY;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003393 curagent->timeout.processing = TICK_ETERNITY;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003394
Christopher Fauleta1cda022016-12-21 08:58:06 +01003395 curagent->var_pfx = NULL;
3396 curagent->var_on_error = NULL;
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003397 curagent->var_t_process = NULL;
3398 curagent->var_t_total = NULL;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003399 curagent->flags = (SPOE_FL_ASYNC | SPOE_FL_PIPELINING | SPOE_FL_SND_FRAGMENTATION);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003400 curagent->cps_max = 0;
3401 curagent->eps_max = 0;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01003402 curagent->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01003403 curagent->max_fpa = 20;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003404
3405 for (i = 0; i < SPOE_EV_EVENTS; ++i)
Christopher Faulet11610f32017-09-21 10:23:10 +02003406 LIST_INIT(&curagent->events[i]);
3407 LIST_INIT(&curagent->groups);
3408 LIST_INIT(&curagent->messages);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003409 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003410 else if (strcmp(args[0], "use-backend") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003411 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003412 ha_alert("parsing [%s:%d] : '%s' expects a backend name.\n",
3413 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003414 err_code |= ERR_ALERT | ERR_FATAL;
3415 goto out;
3416 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003417 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003418 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003419 free(curagent->b.name);
3420 curagent->b.name = strdup(args[1]);
3421 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003422 else if (strcmp(args[0], "messages") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003423 int cur_arg = 1;
3424 while (*args[cur_arg]) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003425 struct spoe_placeholder *ph = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003426
Christopher Faulet11610f32017-09-21 10:23:10 +02003427 list_for_each_entry(ph, &curmphs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003428 if (strcmp(ph->id, args[cur_arg]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003429 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3430 file, linenum, args[cur_arg]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003431 err_code |= ERR_ALERT | ERR_FATAL;
3432 goto out;
3433 }
3434 }
3435
Christopher Faulet11610f32017-09-21 10:23:10 +02003436 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003437 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003438 err_code |= ERR_ALERT | ERR_ABORT;
3439 goto out;
3440 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003441 ph->id = strdup(args[cur_arg]);
3442 LIST_ADDQ(&curmphs, &ph->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003443 cur_arg++;
3444 }
3445 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003446 else if (strcmp(args[0], "groups") == 0) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003447 int cur_arg = 1;
3448 while (*args[cur_arg]) {
3449 struct spoe_placeholder *ph = NULL;
3450
3451 list_for_each_entry(ph, &curgphs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003452 if (strcmp(ph->id, args[cur_arg]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003453 ha_alert("parsing [%s:%d]: spoe-group '%s' already used.\n",
3454 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003455 err_code |= ERR_ALERT | ERR_FATAL;
3456 goto out;
3457 }
3458 }
3459
3460 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003461 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003462 err_code |= ERR_ALERT | ERR_ABORT;
3463 goto out;
3464 }
3465 ph->id = strdup(args[cur_arg]);
3466 LIST_ADDQ(&curgphs, &ph->list);
3467 cur_arg++;
3468 }
3469 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003470 else if (strcmp(args[0], "timeout") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003471 unsigned int *tv = NULL;
3472 const char *res;
3473 unsigned timeout;
3474
3475 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003476 ha_alert("parsing [%s:%d] : 'timeout' expects 'hello', 'idle' and 'processing'.\n",
3477 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003478 err_code |= ERR_ALERT | ERR_FATAL;
3479 goto out;
3480 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003481 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3482 goto out;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003483 if (strcmp(args[1], "hello") == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003484 tv = &curagent->timeout.hello;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003485 else if (strcmp(args[1], "idle") == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003486 tv = &curagent->timeout.idle;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003487 else if (strcmp(args[1], "processing") == 0)
Christopher Fauletf7a30922016-11-10 15:04:51 +01003488 tv = &curagent->timeout.processing;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003489 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003490 ha_alert("parsing [%s:%d] : 'timeout' supports 'hello', 'idle' or 'processing' (got %s).\n",
3491 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003492 err_code |= ERR_ALERT | ERR_FATAL;
3493 goto out;
3494 }
3495 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003496 ha_alert("parsing [%s:%d] : 'timeout %s' expects an integer value (in milliseconds).\n",
3497 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003498 err_code |= ERR_ALERT | ERR_FATAL;
3499 goto out;
3500 }
3501 res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02003502 if (res == PARSE_TIME_OVER) {
3503 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
3504 file, linenum, args[2], args[0], args[1]);
3505 err_code |= ERR_ALERT | ERR_FATAL;
3506 goto out;
3507 }
3508 else if (res == PARSE_TIME_UNDER) {
3509 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
3510 file, linenum, args[2], args[0], args[1]);
3511 err_code |= ERR_ALERT | ERR_FATAL;
3512 goto out;
3513 }
3514 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003515 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'timeout %s'.\n",
3516 file, linenum, *res, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003517 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003518 goto out;
3519 }
3520 *tv = MS_TO_TICKS(timeout);
3521 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003522 else if (strcmp(args[0], "option") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003523 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003524 ha_alert("parsing [%s:%d]: '%s' expects an option name.\n",
3525 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003526 err_code |= ERR_ALERT | ERR_FATAL;
3527 goto out;
3528 }
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003529
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003530 if (strcmp(args[1], "pipelining") == 0) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003531 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003532 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003533 if (kwm == 1)
3534 curagent->flags &= ~SPOE_FL_PIPELINING;
3535 else
3536 curagent->flags |= SPOE_FL_PIPELINING;
3537 goto out;
3538 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003539 else if (strcmp(args[1], "async") == 0) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003540 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003541 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003542 if (kwm == 1)
3543 curagent->flags &= ~SPOE_FL_ASYNC;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003544 else
3545 curagent->flags |= SPOE_FL_ASYNC;
Christopher Faulet305c6072017-02-23 16:17:53 +01003546 goto out;
3547 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003548 else if (strcmp(args[1], "send-frag-payload") == 0) {
Christopher Fauletcecd8522017-02-24 22:11:21 +01003549 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3550 goto out;
3551 if (kwm == 1)
3552 curagent->flags &= ~SPOE_FL_SND_FRAGMENTATION;
3553 else
3554 curagent->flags |= SPOE_FL_SND_FRAGMENTATION;
3555 goto out;
3556 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003557 else if (strcmp(args[1], "dontlog-normal") == 0) {
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003558 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3559 goto out;
3560 if (kwm == 1)
3561 curpxopts2 &= ~PR_O2_NOLOGNORM;
3562 else
3563 curpxopts2 |= PR_O2_NOLOGNORM;
Christopher Faulet799f5182018-04-26 11:36:34 +02003564 goto out;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003565 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003566
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003567 /* Following options does not support negation */
3568 if (kwm == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003569 ha_alert("parsing [%s:%d]: negation is not supported for option '%s'.\n",
3570 file, linenum, args[1]);
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003571 err_code |= ERR_ALERT | ERR_FATAL;
3572 goto out;
3573 }
3574
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003575 if (strcmp(args[1], "var-prefix") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003576 char *tmp;
3577
3578 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003579 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3580 file, linenum, args[0],
3581 args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003582 err_code |= ERR_ALERT | ERR_FATAL;
3583 goto out;
3584 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003585 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3586 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003587 tmp = args[2];
3588 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003589 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003590 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003591 file, linenum, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003592 err_code |= ERR_ALERT | ERR_FATAL;
3593 goto out;
3594 }
3595 tmp++;
3596 }
3597 curagent->var_pfx = strdup(args[2]);
3598 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003599 else if (strcmp(args[1], "force-set-var") == 0) {
Etienne Carriereaec89892017-12-14 09:36:40 +00003600 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3601 goto out;
3602 curagent->flags |= SPOE_FL_FORCE_SET_VAR;
3603 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003604 else if (strcmp(args[1], "continue-on-error") == 0) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003605 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003606 goto out;
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003607 curagent->flags |= SPOE_FL_CONT_ON_ERR;
3608 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003609 else if (strcmp(args[1], "set-on-error") == 0) {
Christopher Faulet985532d2016-11-16 15:36:19 +01003610 char *tmp;
3611
3612 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003613 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3614 file, linenum, args[0],
3615 args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003616 err_code |= ERR_ALERT | ERR_FATAL;
3617 goto out;
3618 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003619 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3620 goto out;
Christopher Faulet985532d2016-11-16 15:36:19 +01003621 tmp = args[2];
3622 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003623 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003624 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003625 file, linenum, args[0], args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003626 err_code |= ERR_ALERT | ERR_FATAL;
3627 goto out;
3628 }
3629 tmp++;
3630 }
3631 curagent->var_on_error = strdup(args[2]);
3632 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003633 else if (strcmp(args[1], "set-process-time") == 0) {
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003634 char *tmp;
3635
3636 if (!*args[2]) {
3637 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3638 file, linenum, args[0],
3639 args[1]);
3640 err_code |= ERR_ALERT | ERR_FATAL;
3641 goto out;
3642 }
3643 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3644 goto out;
3645 tmp = args[2];
3646 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003647 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003648 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003649 file, linenum, args[0], args[1]);
3650 err_code |= ERR_ALERT | ERR_FATAL;
3651 goto out;
3652 }
3653 tmp++;
3654 }
3655 curagent->var_t_process = strdup(args[2]);
3656 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003657 else if (strcmp(args[1], "set-total-time") == 0) {
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003658 char *tmp;
3659
3660 if (!*args[2]) {
3661 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3662 file, linenum, args[0],
3663 args[1]);
3664 err_code |= ERR_ALERT | ERR_FATAL;
3665 goto out;
3666 }
3667 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3668 goto out;
3669 tmp = args[2];
3670 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003671 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003672 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003673 file, linenum, args[0], args[1]);
3674 err_code |= ERR_ALERT | ERR_FATAL;
3675 goto out;
3676 }
3677 tmp++;
3678 }
3679 curagent->var_t_total = strdup(args[2]);
3680 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003681 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003682 ha_alert("parsing [%s:%d]: option '%s' is not supported.\n",
3683 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003684 err_code |= ERR_ALERT | ERR_FATAL;
3685 goto out;
3686 }
Christopher Faulet48026722016-11-16 15:01:12 +01003687 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003688 else if (strcmp(args[0], "maxconnrate") == 0) {
Christopher Faulet48026722016-11-16 15:01:12 +01003689 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003690 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3691 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003692 err_code |= ERR_ALERT | ERR_FATAL;
3693 goto out;
3694 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003695 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003696 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003697 curagent->cps_max = atol(args[1]);
3698 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003699 else if (strcmp(args[0], "maxerrrate") == 0) {
Christopher Faulet48026722016-11-16 15:01:12 +01003700 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003701 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3702 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003703 err_code |= ERR_ALERT | ERR_FATAL;
3704 goto out;
3705 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003706 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003707 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003708 curagent->eps_max = atol(args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003709 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003710 else if (strcmp(args[0], "max-frame-size") == 0) {
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003711 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003712 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3713 file, linenum, args[0]);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003714 err_code |= ERR_ALERT | ERR_FATAL;
3715 goto out;
3716 }
3717 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3718 goto out;
3719 curagent->max_frame_size = atol(args[1]);
3720 if (curagent->max_frame_size < MIN_FRAME_SIZE ||
3721 curagent->max_frame_size > MAX_FRAME_SIZE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003722 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument in the range [%d, %d].\n",
3723 file, linenum, args[0], MIN_FRAME_SIZE, MAX_FRAME_SIZE);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003724 err_code |= ERR_ALERT | ERR_FATAL;
3725 goto out;
3726 }
3727 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003728 else if (strcmp(args[0], "max-waiting-frames") == 0) {
Christopher Faulete8ade382018-01-25 15:32:22 +01003729 if (!*args[1]) {
3730 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3731 file, linenum, args[0]);
3732 err_code |= ERR_ALERT | ERR_FATAL;
3733 goto out;
3734 }
3735 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3736 goto out;
3737 curagent->max_fpa = atol(args[1]);
3738 if (curagent->max_fpa < 1) {
3739 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument.\n",
3740 file, linenum, args[0]);
3741 err_code |= ERR_ALERT | ERR_FATAL;
3742 goto out;
3743 }
3744 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003745 else if (strcmp(args[0], "register-var-names") == 0) {
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003746 int cur_arg;
3747
3748 if (!*args[1]) {
3749 ha_alert("parsing [%s:%d] : '%s' expects one or more variable names.\n",
3750 file, linenum, args[0]);
3751 err_code |= ERR_ALERT | ERR_FATAL;
3752 goto out;
3753 }
3754 cur_arg = 1;
3755 while (*args[cur_arg]) {
3756 struct spoe_var_placeholder *vph;
3757
3758 if ((vph = calloc(1, sizeof(*vph))) == NULL) {
3759 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3760 err_code |= ERR_ALERT | ERR_ABORT;
3761 goto out;
3762 }
3763 if ((vph->name = strdup(args[cur_arg])) == NULL) {
Tim Duesterhusb2986132019-06-23 22:10:13 +02003764 free(vph);
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003765 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3766 err_code |= ERR_ALERT | ERR_ABORT;
3767 goto out;
3768 }
3769 LIST_ADDQ(&curvars, &vph->list);
3770 cur_arg++;
3771 }
3772 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003773 else if (strcmp(args[0], "log") == 0) {
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003774 char *errmsg = NULL;
3775
Emeric Brun9533a702021-04-02 10:13:43 +02003776 if (!parse_logsrv(args, &curlogsrvs, (kwm == 1), file, linenum, &errmsg)) {
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003777 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
3778 err_code |= ERR_ALERT | ERR_FATAL;
3779 goto out;
3780 }
3781 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003782 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003783 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-agent section.\n",
3784 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003785 err_code |= ERR_ALERT | ERR_FATAL;
3786 goto out;
3787 }
3788 out:
3789 return err_code;
3790}
Christopher Faulet11610f32017-09-21 10:23:10 +02003791static int
3792cfg_parse_spoe_group(const char *file, int linenum, char **args, int kwm)
3793{
3794 struct spoe_group *grp;
3795 const char *err;
3796 int err_code = 0;
3797
3798 if ((cfg_scope == NULL && curengine != NULL) ||
3799 (cfg_scope != NULL && curengine == NULL) ||
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003800 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope) != 0))
Christopher Faulet11610f32017-09-21 10:23:10 +02003801 goto out;
3802
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003803 if (strcmp(args[0], "spoe-group") == 0) { /* new spoe-group section */
Christopher Faulet11610f32017-09-21 10:23:10 +02003804 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003805 ha_alert("parsing [%s:%d] : missing name for spoe-group section.\n",
3806 file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003807 err_code |= ERR_ALERT | ERR_ABORT;
3808 goto out;
3809 }
3810 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3811 err_code |= ERR_ABORT;
3812 goto out;
3813 }
3814
3815 err = invalid_char(args[1]);
3816 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003817 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3818 file, linenum, *err, args[0], args[1]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003819 err_code |= ERR_ALERT | ERR_ABORT;
3820 goto out;
3821 }
3822
3823 list_for_each_entry(grp, &curgrps, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003824 if (strcmp(grp->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003825 ha_alert("parsing [%s:%d]: spoe-group section '%s' has the same"
3826 " name as another one declared at %s:%d.\n",
3827 file, linenum, args[1], grp->conf.file, grp->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02003828 err_code |= ERR_ALERT | ERR_FATAL;
3829 goto out;
3830 }
3831 }
3832
3833 if ((curgrp = calloc(1, sizeof(*curgrp))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003834 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003835 err_code |= ERR_ALERT | ERR_ABORT;
3836 goto out;
3837 }
3838
3839 curgrp->id = strdup(args[1]);
3840 curgrp->conf.file = strdup(file);
3841 curgrp->conf.line = linenum;
3842 LIST_INIT(&curgrp->phs);
3843 LIST_INIT(&curgrp->messages);
3844 LIST_ADDQ(&curgrps, &curgrp->list);
3845 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003846 else if (strcmp(args[0], "messages") == 0) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003847 int cur_arg = 1;
3848 while (*args[cur_arg]) {
3849 struct spoe_placeholder *ph = NULL;
3850
3851 list_for_each_entry(ph, &curgrp->phs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003852 if (strcmp(ph->id, args[cur_arg]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003853 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3854 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003855 err_code |= ERR_ALERT | ERR_FATAL;
3856 goto out;
3857 }
3858 }
3859
3860 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003861 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003862 err_code |= ERR_ALERT | ERR_ABORT;
3863 goto out;
3864 }
3865 ph->id = strdup(args[cur_arg]);
3866 LIST_ADDQ(&curgrp->phs, &ph->list);
3867 cur_arg++;
3868 }
3869 }
3870 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003871 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-group section.\n",
3872 file, linenum, args[0]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003873 err_code |= ERR_ALERT | ERR_FATAL;
3874 goto out;
3875 }
3876 out:
3877 return err_code;
3878}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003879
3880static int
3881cfg_parse_spoe_message(const char *file, int linenum, char **args, int kwm)
3882{
3883 struct spoe_message *msg;
3884 struct spoe_arg *arg;
3885 const char *err;
3886 char *errmsg = NULL;
3887 int err_code = 0;
3888
3889 if ((cfg_scope == NULL && curengine != NULL) ||
3890 (cfg_scope != NULL && curengine == NULL) ||
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003891 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope) != 0))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003892 goto out;
3893
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003894 if (strcmp(args[0], "spoe-message") == 0) { /* new spoe-message section */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003895 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003896 ha_alert("parsing [%s:%d] : missing name for spoe-message section.\n",
3897 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003898 err_code |= ERR_ALERT | ERR_ABORT;
3899 goto out;
3900 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003901 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3902 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003903 goto out;
3904 }
3905
3906 err = invalid_char(args[1]);
3907 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003908 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3909 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003910 err_code |= ERR_ALERT | ERR_ABORT;
3911 goto out;
3912 }
3913
3914 list_for_each_entry(msg, &curmsgs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003915 if (strcmp(msg->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003916 ha_alert("parsing [%s:%d]: spoe-message section '%s' has the same"
3917 " name as another one declared at %s:%d.\n",
3918 file, linenum, args[1], msg->conf.file, msg->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003919 err_code |= ERR_ALERT | ERR_FATAL;
3920 goto out;
3921 }
3922 }
3923
3924 if ((curmsg = calloc(1, sizeof(*curmsg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003925 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003926 err_code |= ERR_ALERT | ERR_ABORT;
3927 goto out;
3928 }
3929
3930 curmsg->id = strdup(args[1]);
3931 curmsg->id_len = strlen(curmsg->id);
3932 curmsg->event = SPOE_EV_NONE;
3933 curmsg->conf.file = strdup(file);
3934 curmsg->conf.line = linenum;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003935 curmsg->nargs = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003936 LIST_INIT(&curmsg->args);
Christopher Faulet57583e42017-09-04 15:41:09 +02003937 LIST_INIT(&curmsg->acls);
Christopher Faulet11610f32017-09-21 10:23:10 +02003938 LIST_INIT(&curmsg->by_evt);
3939 LIST_INIT(&curmsg->by_grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003940 LIST_ADDQ(&curmsgs, &curmsg->list);
3941 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003942 else if (strcmp(args[0], "args") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003943 int cur_arg = 1;
3944
3945 curproxy->conf.args.ctx = ARGC_SPOE;
3946 curproxy->conf.args.file = file;
3947 curproxy->conf.args.line = linenum;
3948 while (*args[cur_arg]) {
3949 char *delim = strchr(args[cur_arg], '=');
3950 int idx = 0;
3951
3952 if ((arg = calloc(1, sizeof(*arg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003953 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003954 err_code |= ERR_ALERT | ERR_ABORT;
3955 goto out;
3956 }
3957
3958 if (!delim) {
3959 arg->name = NULL;
3960 arg->name_len = 0;
3961 delim = args[cur_arg];
3962 }
3963 else {
3964 arg->name = my_strndup(args[cur_arg], delim - args[cur_arg]);
3965 arg->name_len = delim - args[cur_arg];
3966 delim++;
3967 }
Christopher Fauletb0b42382017-02-23 22:41:09 +01003968 arg->expr = sample_parse_expr((char*[]){delim, NULL},
3969 &idx, file, linenum, &errmsg,
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01003970 &curproxy->conf.args, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003971 if (arg->expr == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003972 ha_alert("parsing [%s:%d] : '%s': %s.\n", file, linenum, args[0], errmsg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003973 err_code |= ERR_ALERT | ERR_FATAL;
3974 free(arg->name);
3975 free(arg);
3976 goto out;
3977 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003978 curmsg->nargs++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003979 LIST_ADDQ(&curmsg->args, &arg->list);
3980 cur_arg++;
3981 }
3982 curproxy->conf.args.file = NULL;
3983 curproxy->conf.args.line = 0;
3984 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003985 else if (strcmp(args[0], "acl") == 0) {
Christopher Faulet57583e42017-09-04 15:41:09 +02003986 err = invalid_char(args[1]);
3987 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003988 ha_alert("parsing [%s:%d] : character '%c' is not permitted in acl name '%s'.\n",
3989 file, linenum, *err, args[1]);
Christopher Faulet57583e42017-09-04 15:41:09 +02003990 err_code |= ERR_ALERT | ERR_FATAL;
3991 goto out;
3992 }
Tim Duesterhus0cf811a2020-02-05 21:00:50 +01003993 if (strcasecmp(args[1], "or") == 0) {
Tim Duesterhusf1bc24c2020-02-06 22:04:03 +01003994 ha_alert("parsing [%s:%d] : acl name '%s' will never match. 'or' is used to express a "
Tim Duesterhus0cf811a2020-02-05 21:00:50 +01003995 "logical disjunction within a condition.\n",
3996 file, linenum, args[1]);
3997 err_code |= ERR_ALERT | ERR_FATAL;
3998 goto out;
3999 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004000 if (parse_acl((const char **)args + 1, &curmsg->acls, &errmsg, &curproxy->conf.args, file, linenum) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004001 ha_alert("parsing [%s:%d] : error detected while parsing ACL '%s' : %s.\n",
4002 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02004003 err_code |= ERR_ALERT | ERR_FATAL;
4004 goto out;
4005 }
4006 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004007 else if (strcmp(args[0], "event") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004008 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004009 ha_alert("parsing [%s:%d] : missing event name.\n", file, linenum);
Christopher Fauletecc537a2017-02-23 22:52:39 +01004010 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004011 goto out;
4012 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004013 /* if (alertif_too_many_args(1, file, linenum, args, &err_code)) */
4014 /* goto out; */
Christopher Fauletecc537a2017-02-23 22:52:39 +01004015
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004016 if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_CLIENT_SESS]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004017 curmsg->event = SPOE_EV_ON_CLIENT_SESS;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004018 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_SERVER_SESS]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004019 curmsg->event = SPOE_EV_ON_SERVER_SESS;
4020
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004021 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_FE]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004022 curmsg->event = SPOE_EV_ON_TCP_REQ_FE;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004023 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_BE]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004024 curmsg->event = SPOE_EV_ON_TCP_REQ_BE;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004025 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_RSP]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004026 curmsg->event = SPOE_EV_ON_TCP_RSP;
4027
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004028 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_FE]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004029 curmsg->event = SPOE_EV_ON_HTTP_REQ_FE;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004030 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_BE]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004031 curmsg->event = SPOE_EV_ON_HTTP_REQ_BE;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004032 else if (strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_RSP]) == 0)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004033 curmsg->event = SPOE_EV_ON_HTTP_RSP;
4034 else {
Joseph Herlantf1da69d2018-11-15 13:49:02 -08004035 ha_alert("parsing [%s:%d] : unknown event '%s'.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01004036 file, linenum, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01004037 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004038 goto out;
4039 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004040
4041 if (strcmp(args[2], "if") == 0 || strcmp(args[2], "unless") == 0) {
4042 struct acl_cond *cond;
4043
4044 cond = build_acl_cond(file, linenum, &curmsg->acls,
4045 curproxy, (const char **)args+2,
4046 &errmsg);
4047 if (cond == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004048 ha_alert("parsing [%s:%d] : error detected while "
4049 "parsing an 'event %s' condition : %s.\n",
4050 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02004051 err_code |= ERR_ALERT | ERR_FATAL;
4052 goto out;
4053 }
4054 curmsg->cond = cond;
4055 }
4056 else if (*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004057 ha_alert("parsing [%s:%d]: 'event %s' expects either 'if' "
4058 "or 'unless' followed by a condition but found '%s'.\n",
4059 file, linenum, args[1], args[2]);
Christopher Faulet57583e42017-09-04 15:41:09 +02004060 err_code |= ERR_ALERT | ERR_FATAL;
4061 goto out;
4062 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004063 }
4064 else if (!*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004065 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-message section.\n",
4066 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004067 err_code |= ERR_ALERT | ERR_FATAL;
4068 goto out;
4069 }
4070 out:
4071 free(errmsg);
4072 return err_code;
4073}
4074
4075/* Return -1 on error, else 0 */
4076static int
4077parse_spoe_flt(char **args, int *cur_arg, struct proxy *px,
4078 struct flt_conf *fconf, char **err, void *private)
4079{
4080 struct list backup_sections;
4081 struct spoe_config *conf;
4082 struct spoe_message *msg, *msgback;
Christopher Faulet11610f32017-09-21 10:23:10 +02004083 struct spoe_group *grp, *grpback;
4084 struct spoe_placeholder *ph, *phback;
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004085 struct spoe_var_placeholder *vph, *vphback;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004086 struct logsrv *logsrv, *logsrvback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004087 char *file = NULL, *engine = NULL;
4088 int ret, pos = *cur_arg + 1;
4089
Christopher Faulet84c844e2018-03-23 14:37:14 +01004090 LIST_INIT(&curmsgs);
4091 LIST_INIT(&curgrps);
4092 LIST_INIT(&curmphs);
4093 LIST_INIT(&curgphs);
4094 LIST_INIT(&curvars);
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004095 LIST_INIT(&curlogsrvs);
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004096 curpxopts = 0;
4097 curpxopts2 = 0;
Christopher Faulet84c844e2018-03-23 14:37:14 +01004098
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004099 conf = calloc(1, sizeof(*conf));
4100 if (conf == NULL) {
4101 memprintf(err, "%s: out of memory", args[*cur_arg]);
4102 goto error;
4103 }
4104 conf->proxy = px;
4105
4106 while (*args[pos]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004107 if (strcmp(args[pos], "config") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004108 if (!*args[pos+1]) {
4109 memprintf(err, "'%s' : '%s' option without value",
4110 args[*cur_arg], args[pos]);
4111 goto error;
4112 }
4113 file = args[pos+1];
4114 pos += 2;
4115 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004116 else if (strcmp(args[pos], "engine") == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004117 if (!*args[pos+1]) {
4118 memprintf(err, "'%s' : '%s' option without value",
4119 args[*cur_arg], args[pos]);
4120 goto error;
4121 }
4122 engine = args[pos+1];
4123 pos += 2;
4124 }
4125 else {
4126 memprintf(err, "unknown keyword '%s'", args[pos]);
4127 goto error;
4128 }
4129 }
4130 if (file == NULL) {
4131 memprintf(err, "'%s' : missing config file", args[*cur_arg]);
4132 goto error;
4133 }
4134
4135 /* backup sections and register SPOE sections */
4136 LIST_INIT(&backup_sections);
4137 cfg_backup_sections(&backup_sections);
Christopher Faulet11610f32017-09-21 10:23:10 +02004138 cfg_register_section("spoe-agent", cfg_parse_spoe_agent, NULL);
4139 cfg_register_section("spoe-group", cfg_parse_spoe_group, NULL);
William Lallemandd2ff56d2017-10-16 11:06:50 +02004140 cfg_register_section("spoe-message", cfg_parse_spoe_message, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004141
4142 /* Parse SPOE filter configuration file */
4143 curengine = engine;
4144 curproxy = px;
4145 curagent = NULL;
4146 curmsg = NULL;
4147 ret = readcfgfile(file);
4148 curproxy = NULL;
4149
4150 /* unregister SPOE sections and restore previous sections */
4151 cfg_unregister_sections();
4152 cfg_restore_sections(&backup_sections);
4153
4154 if (ret == -1) {
4155 memprintf(err, "Could not open configuration file %s : %s",
4156 file, strerror(errno));
4157 goto error;
4158 }
4159 if (ret & (ERR_ABORT|ERR_FATAL)) {
4160 memprintf(err, "Error(s) found in configuration file %s", file);
4161 goto error;
4162 }
4163
4164 /* Check SPOE agent */
4165 if (curagent == NULL) {
4166 memprintf(err, "No SPOE agent found in file %s", file);
4167 goto error;
4168 }
4169 if (curagent->b.name == NULL) {
4170 memprintf(err, "No backend declared for SPOE agent '%s' declared at %s:%d",
4171 curagent->id, curagent->conf.file, curagent->conf.line);
4172 goto error;
4173 }
Christopher Fauletf7a30922016-11-10 15:04:51 +01004174 if (curagent->timeout.hello == TICK_ETERNITY ||
4175 curagent->timeout.idle == TICK_ETERNITY ||
Christopher Fauletf7a30922016-11-10 15:04:51 +01004176 curagent->timeout.processing == TICK_ETERNITY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004177 ha_warning("Proxy '%s': missing timeouts for SPOE agent '%s' declare at %s:%d.\n"
4178 " | While not properly invalid, you will certainly encounter various problems\n"
4179 " | with such a configuration. To fix this, please ensure that all following\n"
4180 " | timeouts are set to a non-zero value: 'hello', 'idle', 'processing'.\n",
4181 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004182 }
4183 if (curagent->var_pfx == NULL) {
4184 char *tmp = curagent->id;
4185
4186 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01004187 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004188 memprintf(err, "Invalid variable prefix '%s' for SPOE agent '%s' declared at %s:%d. "
4189 "Use 'option var-prefix' to set it. Only [a-zA-Z0-9_.] chars are supported.\n",
4190 curagent->id, curagent->id, curagent->conf.file, curagent->conf.line);
4191 goto error;
4192 }
4193 tmp++;
4194 }
4195 curagent->var_pfx = strdup(curagent->id);
4196 }
4197
Christopher Fauletb7426d12018-03-21 14:12:17 +01004198 if (curagent->var_on_error) {
4199 struct arg arg;
4200
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004201 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Fauletb7426d12018-03-21 14:12:17 +01004202 curagent->var_pfx, curagent->var_on_error);
4203
4204 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004205 arg.data.str.area = trash.area;
4206 arg.data.str.data = trash.data;
William Dauchyafb93682021-01-05 11:14:58 +01004207 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_arg() */
Christopher Fauletb7426d12018-03-21 14:12:17 +01004208 if (!vars_check_arg(&arg, err)) {
4209 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4210 curagent->id, curagent->var_pfx, curagent->var_on_error, *err);
4211 goto error;
4212 }
4213 }
4214
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004215 if (curagent->var_t_process) {
4216 struct arg arg;
4217
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004218 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004219 curagent->var_pfx, curagent->var_t_process);
4220
4221 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004222 arg.data.str.area = trash.area;
4223 arg.data.str.data = trash.data;
William Dauchyafb93682021-01-05 11:14:58 +01004224 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_arg() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004225 if (!vars_check_arg(&arg, err)) {
4226 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4227 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4228 goto error;
4229 }
4230 }
4231
4232 if (curagent->var_t_total) {
4233 struct arg arg;
4234
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004235 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004236 curagent->var_pfx, curagent->var_t_total);
4237
4238 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004239 arg.data.str.area = trash.area;
4240 arg.data.str.data = trash.data;
William Dauchyafb93682021-01-05 11:14:58 +01004241 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_arg() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004242 if (!vars_check_arg(&arg, err)) {
4243 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4244 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4245 goto error;
4246 }
4247 }
4248
Christopher Faulet11610f32017-09-21 10:23:10 +02004249 if (LIST_ISEMPTY(&curmphs) && LIST_ISEMPTY(&curgphs)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004250 ha_warning("Proxy '%s': No message/group used by SPOE agent '%s' declared at %s:%d.\n",
4251 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004252 goto finish;
4253 }
4254
Christopher Faulet11610f32017-09-21 10:23:10 +02004255 /* Replace placeholders by the corresponding messages for the SPOE
4256 * agent */
4257 list_for_each_entry(ph, &curmphs, list) {
4258 list_for_each_entry(msg, &curmsgs, list) {
Christopher Fauleta21b0642017-01-09 16:56:23 +01004259 struct spoe_arg *arg;
4260 unsigned int where;
4261
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004262 if (strcmp(msg->id, ph->id) == 0) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004263 if ((px->cap & (PR_CAP_FE|PR_CAP_BE)) == (PR_CAP_FE|PR_CAP_BE)) {
4264 if (msg->event == SPOE_EV_ON_TCP_REQ_BE)
4265 msg->event = SPOE_EV_ON_TCP_REQ_FE;
4266 if (msg->event == SPOE_EV_ON_HTTP_REQ_BE)
4267 msg->event = SPOE_EV_ON_HTTP_REQ_FE;
4268 }
4269 if (!(px->cap & PR_CAP_FE) && (msg->event == SPOE_EV_ON_CLIENT_SESS ||
4270 msg->event == SPOE_EV_ON_TCP_REQ_FE ||
4271 msg->event == SPOE_EV_ON_HTTP_REQ_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004272 ha_warning("Proxy '%s': frontend event used on a backend proxy at %s:%d.\n",
4273 px->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004274 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004275 }
4276 if (msg->event == SPOE_EV_NONE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004277 ha_warning("Proxy '%s': Ignore SPOE message '%s' without event at %s:%d.\n",
4278 px->id, msg->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004279 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004280 }
Christopher Fauleta21b0642017-01-09 16:56:23 +01004281
4282 where = 0;
4283 switch (msg->event) {
4284 case SPOE_EV_ON_CLIENT_SESS:
4285 where |= SMP_VAL_FE_CON_ACC;
4286 break;
4287
4288 case SPOE_EV_ON_TCP_REQ_FE:
4289 where |= SMP_VAL_FE_REQ_CNT;
4290 break;
4291
4292 case SPOE_EV_ON_HTTP_REQ_FE:
4293 where |= SMP_VAL_FE_HRQ_HDR;
4294 break;
4295
4296 case SPOE_EV_ON_TCP_REQ_BE:
4297 if (px->cap & PR_CAP_FE)
4298 where |= SMP_VAL_FE_REQ_CNT;
4299 if (px->cap & PR_CAP_BE)
4300 where |= SMP_VAL_BE_REQ_CNT;
4301 break;
4302
4303 case SPOE_EV_ON_HTTP_REQ_BE:
4304 if (px->cap & PR_CAP_FE)
4305 where |= SMP_VAL_FE_HRQ_HDR;
4306 if (px->cap & PR_CAP_BE)
4307 where |= SMP_VAL_BE_HRQ_HDR;
4308 break;
4309
4310 case SPOE_EV_ON_SERVER_SESS:
4311 where |= SMP_VAL_BE_SRV_CON;
4312 break;
4313
4314 case SPOE_EV_ON_TCP_RSP:
4315 if (px->cap & PR_CAP_FE)
4316 where |= SMP_VAL_FE_RES_CNT;
4317 if (px->cap & PR_CAP_BE)
4318 where |= SMP_VAL_BE_RES_CNT;
4319 break;
4320
4321 case SPOE_EV_ON_HTTP_RSP:
4322 if (px->cap & PR_CAP_FE)
4323 where |= SMP_VAL_FE_HRS_HDR;
4324 if (px->cap & PR_CAP_BE)
4325 where |= SMP_VAL_BE_HRS_HDR;
4326 break;
4327
4328 default:
4329 break;
4330 }
4331
4332 list_for_each_entry(arg, &msg->args, list) {
4333 if (!(arg->expr->fetch->val & where)) {
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004334 memprintf(err, "Ignore SPOE message '%s' at %s:%d: "
Christopher Fauleta21b0642017-01-09 16:56:23 +01004335 "some args extract information from '%s', "
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004336 "none of which is available here ('%s')",
4337 msg->id, msg->conf.file, msg->conf.line,
Christopher Fauleta21b0642017-01-09 16:56:23 +01004338 sample_ckp_names(arg->expr->fetch->use),
4339 sample_ckp_names(where));
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004340 goto error;
Christopher Fauleta21b0642017-01-09 16:56:23 +01004341 }
4342 }
4343
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004344 msg->agent = curagent;
Christopher Faulet11610f32017-09-21 10:23:10 +02004345 LIST_ADDQ(&curagent->events[msg->event], &msg->by_evt);
4346 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004347 }
4348 }
4349 memprintf(err, "SPOE agent '%s' try to use undefined SPOE message '%s' at %s:%d",
Christopher Faulet11610f32017-09-21 10:23:10 +02004350 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004351 goto error;
Christopher Faulet11610f32017-09-21 10:23:10 +02004352 next_mph:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004353 continue;
4354 }
4355
Christopher Faulet11610f32017-09-21 10:23:10 +02004356 /* Replace placeholders by the corresponding groups for the SPOE
4357 * agent */
4358 list_for_each_entry(ph, &curgphs, list) {
4359 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004360 if (strcmp(grp->id, ph->id) == 0) {
Christopher Faulet11610f32017-09-21 10:23:10 +02004361 grp->agent = curagent;
4362 LIST_DEL(&grp->list);
4363 LIST_ADDQ(&curagent->groups, &grp->list);
4364 goto next_aph;
4365 }
4366 }
4367 memprintf(err, "SPOE agent '%s' try to use undefined SPOE group '%s' at %s:%d",
4368 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
4369 goto error;
4370 next_aph:
4371 continue;
4372 }
4373
4374 /* Replace placeholders by the corresponding message for each SPOE
4375 * group of the SPOE agent */
4376 list_for_each_entry(grp, &curagent->groups, list) {
4377 list_for_each_entry_safe(ph, phback, &grp->phs, list) {
4378 list_for_each_entry(msg, &curmsgs, list) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004379 if (strcmp(msg->id, ph->id) == 0) {
Christopher Faulet11610f32017-09-21 10:23:10 +02004380 if (msg->group != NULL) {
4381 memprintf(err, "SPOE message '%s' already belongs to "
4382 "the SPOE group '%s' declare at %s:%d",
4383 msg->id, msg->group->id,
4384 msg->group->conf.file,
4385 msg->group->conf.line);
4386 goto error;
4387 }
4388
4389 /* Scope for arguments are not checked for now. We will check
4390 * them only if a rule use the corresponding SPOE group. */
4391 msg->agent = curagent;
4392 msg->group = grp;
4393 LIST_DEL(&ph->list);
4394 LIST_ADDQ(&grp->messages, &msg->by_grp);
4395 goto next_mph_grp;
4396 }
4397 }
4398 memprintf(err, "SPOE group '%s' try to use undefined SPOE message '%s' at %s:%d",
4399 grp->id, ph->id, curagent->conf.file, curagent->conf.line);
4400 goto error;
4401 next_mph_grp:
4402 continue;
4403 }
4404 }
4405
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004406 finish:
Christopher Faulet11610f32017-09-21 10:23:10 +02004407 /* move curmsgs to the agent message list */
4408 curmsgs.n->p = &curagent->messages;
4409 curmsgs.p->n = &curagent->messages;
4410 curagent->messages = curmsgs;
4411 LIST_INIT(&curmsgs);
4412
Christopher Faulet7ee86672017-09-19 11:08:28 +02004413 conf->id = strdup(engine ? engine : curagent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004414 conf->agent = curagent;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004415
4416 /* Start agent's proxy initialization here. It will be finished during
4417 * the filter init. */
4418 memset(&conf->agent_fe, 0, sizeof(conf->agent_fe));
4419 init_new_proxy(&conf->agent_fe);
4420 conf->agent_fe.id = conf->agent->id;
4421 conf->agent_fe.parent = conf->agent;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004422 conf->agent_fe.options |= curpxopts;
4423 conf->agent_fe.options2 |= curpxopts2;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004424
4425 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4426 LIST_DEL(&logsrv->list);
4427 LIST_ADDQ(&conf->agent_fe.logsrvs, &logsrv->list);
4428 }
4429
Christopher Faulet11610f32017-09-21 10:23:10 +02004430 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4431 LIST_DEL(&ph->list);
4432 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004433 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004434 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4435 LIST_DEL(&ph->list);
4436 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004437 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004438 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4439 struct arg arg;
4440
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004441 trash.data = snprintf(trash.area, trash.size, "proc.%s.%s",
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004442 curagent->var_pfx, vph->name);
4443
4444 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004445 arg.data.str.area = trash.area;
4446 arg.data.str.data = trash.data;
William Dauchyafb93682021-01-05 11:14:58 +01004447 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_arg() */
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004448 if (!vars_check_arg(&arg, err)) {
4449 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4450 curagent->id, curagent->var_pfx, vph->name, *err);
4451 goto error;
4452 }
4453
4454 LIST_DEL(&vph->list);
4455 free(vph->name);
4456 free(vph);
4457 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004458 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4459 LIST_DEL(&grp->list);
4460 spoe_release_group(grp);
4461 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004462 *cur_arg = pos;
Christopher Faulet3b386a32017-02-23 10:17:15 +01004463 fconf->id = spoe_filter_id;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004464 fconf->ops = &spoe_ops;
4465 fconf->conf = conf;
4466 return 0;
4467
4468 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01004469 spoe_release_agent(curagent);
Christopher Faulet11610f32017-09-21 10:23:10 +02004470 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4471 LIST_DEL(&ph->list);
4472 spoe_release_placeholder(ph);
4473 }
4474 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4475 LIST_DEL(&ph->list);
4476 spoe_release_placeholder(ph);
4477 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004478 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4479 LIST_DEL(&vph->list);
4480 free(vph->name);
4481 free(vph);
4482 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004483 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4484 LIST_DEL(&grp->list);
4485 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004486 }
4487 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
4488 LIST_DEL(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01004489 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004490 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004491 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4492 LIST_DEL(&logsrv->list);
4493 free(logsrv);
4494 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004495 free(conf);
4496 return -1;
4497}
4498
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004499/* Send message of a SPOE group. This is the action_ptr callback of a rule
4500 * associated to a "send-spoe-group" action.
4501 *
Christopher Faulet13403762019-12-13 09:01:57 +01004502 * It returns ACT_RET_CONT if processing is finished (with error or not), it returns
4503 * ACT_RET_YIELD if the action is in progress. */
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004504static enum act_return
4505spoe_send_group(struct act_rule *rule, struct proxy *px,
4506 struct session *sess, struct stream *s, int flags)
4507{
4508 struct filter *filter;
4509 struct spoe_agent *agent = NULL;
4510 struct spoe_group *group = NULL;
4511 struct spoe_context *ctx = NULL;
4512 int ret, dir;
4513
4514 list_for_each_entry(filter, &s->strm_flt.filters, list) {
4515 if (filter->config == rule->arg.act.p[0]) {
4516 agent = rule->arg.act.p[2];
4517 group = rule->arg.act.p[3];
4518 ctx = filter->ctx;
4519 break;
4520 }
4521 }
4522 if (agent == NULL || group == NULL || ctx == NULL)
Christopher Faulet13403762019-12-13 09:01:57 +01004523 return ACT_RET_CONT;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004524 if (ctx->state == SPOE_CTX_ST_NONE)
4525 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004526
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004527 switch (rule->from) {
4528 case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break;
4529 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
4530 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
4531 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
4532 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
4533 default:
4534 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4535 " - internal error while execute spoe-send-group\n",
4536 (int)now.tv_sec, (int)now.tv_usec, agent->id,
4537 __FUNCTION__, s);
4538 send_log(px, LOG_ERR, "SPOE: [%s] internal error while execute spoe-send-group\n",
4539 agent->id);
4540 return ACT_RET_CONT;
4541 }
4542
4543 ret = spoe_process_group(s, ctx, group, dir);
4544 if (ret == 1)
4545 return ACT_RET_CONT;
4546 else if (ret == 0) {
Christopher Faulet105ba6c2019-12-18 14:41:51 +01004547 if (flags & ACT_OPT_FINAL) {
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004548 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4549 " - failed to process group '%s': interrupted by caller\n",
4550 (int)now.tv_sec, (int)now.tv_usec,
4551 agent->id, __FUNCTION__, s, group->id);
4552 ctx->status_code = SPOE_CTX_ERR_INTERRUPT;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01004553 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02004554 spoe_handle_processing_error(s, agent, ctx, dir);
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004555 return ACT_RET_CONT;
4556 }
4557 return ACT_RET_YIELD;
4558 }
4559 else
Christopher Faulet13403762019-12-13 09:01:57 +01004560 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004561}
4562
4563/* Check an "send-spoe-group" action. Here, we'll try to find the real SPOE
4564 * group associated to <rule>. The format of an rule using 'send-spoe-group'
4565 * action should be:
4566 *
4567 * (http|tcp)-(request|response) send-spoe-group <engine-id> <group-id>
4568 *
4569 * So, we'll loop on each configured SPOE filter for the proxy <px> to find the
4570 * SPOE engine matching <engine-id>. And then, we'll try to find the good group
4571 * matching <group-id>. Finally, we'll check all messages referenced by the SPOE
4572 * group.
4573 *
4574 * The function returns 1 in success case, otherwise, it returns 0 and err is
4575 * filled.
4576 */
4577static int
4578check_send_spoe_group(struct act_rule *rule, struct proxy *px, char **err)
4579{
4580 struct flt_conf *fconf;
4581 struct spoe_config *conf;
4582 struct spoe_agent *agent = NULL;
4583 struct spoe_group *group;
4584 struct spoe_message *msg;
4585 char *engine_id = rule->arg.act.p[0];
4586 char *group_id = rule->arg.act.p[1];
4587 unsigned int where = 0;
4588
4589 switch (rule->from) {
4590 case ACT_F_TCP_REQ_SES: where = SMP_VAL_FE_SES_ACC; break;
4591 case ACT_F_TCP_REQ_CNT: where = SMP_VAL_FE_REQ_CNT; break;
4592 case ACT_F_TCP_RES_CNT: where = SMP_VAL_BE_RES_CNT; break;
4593 case ACT_F_HTTP_REQ: where = SMP_VAL_FE_HRQ_HDR; break;
4594 case ACT_F_HTTP_RES: where = SMP_VAL_BE_HRS_HDR; break;
4595 default:
4596 memprintf(err,
4597 "internal error, unexpected rule->from=%d, please report this bug!",
4598 rule->from);
4599 goto error;
4600 }
4601
4602 /* Try to find the SPOE engine by checking all SPOE filters for proxy
4603 * <px> */
4604 list_for_each_entry(fconf, &px->filter_configs, list) {
4605 conf = fconf->conf;
4606
4607 /* This is not an SPOE filter */
4608 if (fconf->id != spoe_filter_id)
4609 continue;
4610
4611 /* This is the good engine */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004612 if (strcmp(conf->id, engine_id) == 0) {
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004613 agent = conf->agent;
4614 break;
4615 }
4616 }
4617 if (agent == NULL) {
4618 memprintf(err, "unable to find SPOE engine '%s' used by the send-spoe-group '%s'",
4619 engine_id, group_id);
4620 goto error;
4621 }
4622
4623 /* Try to find the right group */
4624 list_for_each_entry(group, &agent->groups, list) {
4625 /* This is the good group */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01004626 if (strcmp(group->id, group_id) == 0)
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004627 break;
4628 }
4629 if (&group->list == &agent->groups) {
4630 memprintf(err, "unable to find SPOE group '%s' into SPOE engine '%s' configuration",
4631 group_id, engine_id);
4632 goto error;
4633 }
4634
4635 /* Ok, we found the group, we need to check messages and their
4636 * arguments */
4637 list_for_each_entry(msg, &group->messages, by_grp) {
4638 struct spoe_arg *arg;
4639
4640 list_for_each_entry(arg, &msg->args, list) {
4641 if (!(arg->expr->fetch->val & where)) {
4642 memprintf(err, "Invalid SPOE message '%s' used by SPOE group '%s' at %s:%d: "
4643 "some args extract information from '%s',"
4644 "none of which is available here ('%s')",
4645 msg->id, group->id, msg->conf.file, msg->conf.line,
4646 sample_ckp_names(arg->expr->fetch->use),
4647 sample_ckp_names(where));
4648 goto error;
4649 }
4650 }
4651 }
4652
4653 free(engine_id);
4654 free(group_id);
4655 rule->arg.act.p[0] = fconf; /* Associate filter config with the rule */
4656 rule->arg.act.p[1] = conf; /* Associate SPOE config with the rule */
4657 rule->arg.act.p[2] = agent; /* Associate SPOE agent with the rule */
4658 rule->arg.act.p[3] = group; /* Associate SPOE group with the rule */
4659 return 1;
4660
4661 error:
4662 free(engine_id);
4663 free(group_id);
4664 return 0;
4665}
4666
4667/* Parse 'send-spoe-group' action following the format:
4668 *
4669 * ... send-spoe-group <engine-id> <group-id>
4670 *
4671 * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error
4672 * message. Otherwise, it returns ACT_RET_PRS_OK and parsing engine and group
4673 * ids are saved and used later, when the rule will be checked.
4674 */
4675static enum act_parse_ret
4676parse_send_spoe_group(const char **args, int *orig_arg, struct proxy *px,
4677 struct act_rule *rule, char **err)
4678{
4679 if (!*args[*orig_arg] || !*args[*orig_arg+1] ||
4680 (*args[*orig_arg+2] && strcmp(args[*orig_arg+2], "if") != 0 && strcmp(args[*orig_arg+2], "unless") != 0)) {
4681 memprintf(err, "expects 2 arguments: <engine-id> <group-id>");
4682 return ACT_RET_PRS_ERR;
4683 }
4684 rule->arg.act.p[0] = strdup(args[*orig_arg]); /* Copy the SPOE engine id */
4685 rule->arg.act.p[1] = strdup(args[*orig_arg+1]); /* Cope the SPOE group id */
4686
4687 (*orig_arg) += 2;
4688
4689 rule->action = ACT_CUSTOM;
4690 rule->action_ptr = spoe_send_group;
4691 rule->check_ptr = check_send_spoe_group;
4692 return ACT_RET_PRS_OK;
4693}
4694
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004695
4696/* Declare the filter parser for "spoe" keyword */
4697static struct flt_kw_list flt_kws = { "SPOE", { }, {
4698 { "spoe", parse_spoe_flt, NULL },
4699 { NULL, NULL, NULL },
4700 }
4701};
4702
Willy Tarreau0108d902018-11-25 19:14:37 +01004703INITCALL1(STG_REGISTER, flt_register_keywords, &flt_kws);
4704
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004705/* Delcate the action parser for "spoe-action" keyword */
4706static struct action_kw_list tcp_req_action_kws = { { }, {
4707 { "send-spoe-group", parse_send_spoe_group },
4708 { /* END */ },
4709 }
4710};
Willy Tarreau0108d902018-11-25 19:14:37 +01004711
4712INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_action_kws);
4713
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004714static struct action_kw_list tcp_res_action_kws = { { }, {
4715 { "send-spoe-group", parse_send_spoe_group },
4716 { /* END */ },
4717 }
4718};
Willy Tarreau0108d902018-11-25 19:14:37 +01004719
4720INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_action_kws);
4721
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004722static struct action_kw_list http_req_action_kws = { { }, {
4723 { "send-spoe-group", parse_send_spoe_group },
4724 { /* END */ },
4725 }
4726};
Willy Tarreau0108d902018-11-25 19:14:37 +01004727
4728INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_action_kws);
4729
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004730static struct action_kw_list http_res_action_kws = { { }, {
4731 { "send-spoe-group", parse_send_spoe_group },
4732 { /* END */ },
4733 }
4734};
4735
Willy Tarreau0108d902018-11-25 19:14:37 +01004736INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_action_kws);