blob: f20b2640baf41fdce61734e24f98e5a748c7a721 [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
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020015#include <common/cfgparse.h>
16#include <common/compat.h>
17#include <common/config.h>
18#include <common/debug.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010019#include <common/hathreads.h>
20#include <common/initcall.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020021#include <common/memory.h>
22#include <common/time.h>
23
24#include <types/arg.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020025#include <types/global.h>
Christopher Faulet1f40b912017-02-17 09:32:19 +010026#include <types/spoe.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020027
Christopher Faulet57583e42017-09-04 15:41:09 +020028#include <proto/acl.h>
Christopher Faulet76c09ef2017-09-21 11:03:52 +020029#include <proto/action.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020030#include <proto/arg.h>
31#include <proto/backend.h>
32#include <proto/filters.h>
Christopher Faulet48026722016-11-16 15:01:12 +010033#include <proto/freq_ctr.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020034#include <proto/frontend.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020035#include <proto/http_rules.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020036#include <proto/log.h>
37#include <proto/proto_http.h>
38#include <proto/proxy.h>
39#include <proto/sample.h>
40#include <proto/session.h>
41#include <proto/signal.h>
Christopher Faulet4ff3e572017-02-24 14:31:11 +010042#include <proto/spoe.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020043#include <proto/stream.h>
44#include <proto/stream_interface.h>
45#include <proto/task.h>
Christopher Faulet76c09ef2017-09-21 11:03:52 +020046#include <proto/tcp_rules.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020047#include <proto/vars.h>
48
49#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
50#define SPOE_PRINTF(x...) fprintf(x)
Christopher Fauletb077cdc2018-01-24 16:37:57 +010051#define SPOE_DEBUG_STMT(statement) statement
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020052#else
53#define SPOE_PRINTF(x...)
Christopher Fauletb077cdc2018-01-24 16:37:57 +010054#define SPOE_DEBUG_STMT(statement)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020055#endif
56
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +010057/* Reserved 4 bytes to the frame size. So a frame and its size can be written
58 * together in a buffer */
59#define MAX_FRAME_SIZE global.tune.bufsize - 4
60
61/* The minimum size for a frame */
62#define MIN_FRAME_SIZE 256
63
Christopher Fauletf51f5fa2017-01-19 10:01:12 +010064/* Reserved for the metadata and the frame type.
65 * So <MAX_FRAME_SIZE> - <FRAME_HDR_SIZE> is the maximum payload size */
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +010066#define FRAME_HDR_SIZE 32
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020067
Christopher Fauletf51f5fa2017-01-19 10:01:12 +010068/* Helper to get SPOE ctx inside an appctx */
Christopher Faulet42bfa462017-01-04 14:14:19 +010069#define SPOE_APPCTX(appctx) ((struct spoe_appctx *)((appctx)->ctx.spoe.ptr))
70
Christopher Faulet3b386a32017-02-23 10:17:15 +010071/* SPOE filter id. Used to identify SPOE filters */
72const char *spoe_filter_id = "SPOE filter";
73
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020074/* Set if the handle on SIGUSR1 is registered */
75static int sighandler_registered = 0;
76
77/* proxy used during the parsing */
78struct proxy *curproxy = NULL;
79
80/* The name of the SPOE engine, used during the parsing */
81char *curengine = NULL;
82
83/* SPOE agent used during the parsing */
Christopher Faulet11610f32017-09-21 10:23:10 +020084/* SPOE agent/group/message used during the parsing */
85struct spoe_agent *curagent = NULL;
86struct spoe_group *curgrp = NULL;
87struct spoe_message *curmsg = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020088
89/* list of SPOE messages and placeholders used during the parsing */
90struct list curmsgs;
Christopher Faulet11610f32017-09-21 10:23:10 +020091struct list curgrps;
92struct list curmphs;
93struct list curgphs;
Christopher Faulet336d3ef2017-12-22 10:00:55 +010094struct list curvars;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020095
Christopher Faulet7250b8f2018-03-26 17:19:01 +020096/* list of log servers used during the parsing */
97struct list curlogsrvs;
98
Christopher Faulet0e0f0852018-03-26 17:20:36 +020099/* agent's proxy flags (PR_O_* and PR_O2_*) used during parsing */
100int curpxopts;
101int curpxopts2;
102
Christopher Faulet42bfa462017-01-04 14:14:19 +0100103/* Pools used to allocate SPOE structs */
Willy Tarreau8ceae722018-11-26 11:58:30 +0100104DECLARE_STATIC_POOL(pool_head_spoe_ctx, "spoe_ctx", sizeof(struct spoe_context));
105DECLARE_STATIC_POOL(pool_head_spoe_appctx, "spoe_appctx", sizeof(struct spoe_appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200106
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200107struct flt_ops spoe_ops;
108
Christopher Faulet8ef75252017-02-20 22:56:03 +0100109static int spoe_queue_context(struct spoe_context *ctx);
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200110static int spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait);
111static void spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200112
113/********************************************************************
114 * helper functions/globals
115 ********************************************************************/
116static void
Christopher Faulet11610f32017-09-21 10:23:10 +0200117spoe_release_placeholder(struct spoe_placeholder *ph)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200118{
Christopher Faulet11610f32017-09-21 10:23:10 +0200119 if (!ph)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200120 return;
Christopher Faulet11610f32017-09-21 10:23:10 +0200121 free(ph->id);
122 free(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200123}
124
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200125static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100126spoe_release_message(struct spoe_message *msg)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200127{
Christopher Faulet57583e42017-09-04 15:41:09 +0200128 struct spoe_arg *arg, *argback;
129 struct acl *acl, *aclback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200130
131 if (!msg)
132 return;
133 free(msg->id);
134 free(msg->conf.file);
Christopher Faulet57583e42017-09-04 15:41:09 +0200135 list_for_each_entry_safe(arg, argback, &msg->args, list) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200136 release_sample_expr(arg->expr);
137 free(arg->name);
138 LIST_DEL(&arg->list);
139 free(arg);
140 }
Christopher Faulet57583e42017-09-04 15:41:09 +0200141 list_for_each_entry_safe(acl, aclback, &msg->acls, list) {
142 LIST_DEL(&acl->list);
143 prune_acl(acl);
144 free(acl);
145 }
146 if (msg->cond) {
147 prune_acl_cond(msg->cond);
148 free(msg->cond);
149 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200150 free(msg);
151}
152
153static void
Christopher Faulet11610f32017-09-21 10:23:10 +0200154spoe_release_group(struct spoe_group *grp)
155{
156 if (!grp)
157 return;
158 free(grp->id);
159 free(grp->conf.file);
160 free(grp);
161}
162
163static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100164spoe_release_agent(struct spoe_agent *agent)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200165{
Christopher Faulet11610f32017-09-21 10:23:10 +0200166 struct spoe_message *msg, *msgback;
167 struct spoe_group *grp, *grpback;
Christopher Faulet24289f22017-09-25 14:48:02 +0200168 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200169
170 if (!agent)
171 return;
172 free(agent->id);
173 free(agent->conf.file);
174 free(agent->var_pfx);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100175 free(agent->engine_id);
Christopher Faulet985532d2016-11-16 15:36:19 +0100176 free(agent->var_on_error);
Christopher Faulet36bda1c2018-03-22 09:08:20 +0100177 free(agent->var_t_process);
178 free(agent->var_t_total);
Christopher Faulet11610f32017-09-21 10:23:10 +0200179 list_for_each_entry_safe(msg, msgback, &agent->messages, list) {
180 LIST_DEL(&msg->list);
181 spoe_release_message(msg);
182 }
183 list_for_each_entry_safe(grp, grpback, &agent->groups, list) {
184 LIST_DEL(&grp->list);
185 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200186 }
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100187 if (agent->rt) {
188 for (i = 0; i < global.nbthread; ++i)
189 HA_SPIN_DESTROY(&agent->rt[i].lock);
190 }
Christopher Faulet24289f22017-09-25 14:48:02 +0200191 free(agent->rt);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200192 free(agent);
193}
194
195static const char *spoe_frm_err_reasons[SPOE_FRM_ERRS] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100196 [SPOE_FRM_ERR_NONE] = "normal",
197 [SPOE_FRM_ERR_IO] = "I/O error",
198 [SPOE_FRM_ERR_TOUT] = "a timeout occurred",
199 [SPOE_FRM_ERR_TOO_BIG] = "frame is too big",
200 [SPOE_FRM_ERR_INVALID] = "invalid frame received",
201 [SPOE_FRM_ERR_NO_VSN] = "version value not found",
202 [SPOE_FRM_ERR_NO_FRAME_SIZE] = "max-frame-size value not found",
203 [SPOE_FRM_ERR_NO_CAP] = "capabilities value not found",
204 [SPOE_FRM_ERR_BAD_VSN] = "unsupported version",
205 [SPOE_FRM_ERR_BAD_FRAME_SIZE] = "max-frame-size too big or too small",
206 [SPOE_FRM_ERR_FRAG_NOT_SUPPORTED] = "fragmentation not supported",
207 [SPOE_FRM_ERR_INTERLACED_FRAMES] = "invalid interlaced frames",
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100208 [SPOE_FRM_ERR_FRAMEID_NOTFOUND] = "frame-id not found",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100209 [SPOE_FRM_ERR_RES] = "resource allocation error",
210 [SPOE_FRM_ERR_UNKNOWN] = "an unknown error occurred",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200211};
212
213static const char *spoe_event_str[SPOE_EV_EVENTS] = {
214 [SPOE_EV_ON_CLIENT_SESS] = "on-client-session",
215 [SPOE_EV_ON_TCP_REQ_FE] = "on-frontend-tcp-request",
216 [SPOE_EV_ON_TCP_REQ_BE] = "on-backend-tcp-request",
217 [SPOE_EV_ON_HTTP_REQ_FE] = "on-frontend-http-request",
218 [SPOE_EV_ON_HTTP_REQ_BE] = "on-backend-http-request",
219
220 [SPOE_EV_ON_SERVER_SESS] = "on-server-session",
221 [SPOE_EV_ON_TCP_RSP] = "on-tcp-response",
222 [SPOE_EV_ON_HTTP_RSP] = "on-http-response",
223};
224
225
226#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
227
228static const char *spoe_ctx_state_str[SPOE_CTX_ST_ERROR+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100229 [SPOE_CTX_ST_NONE] = "NONE",
230 [SPOE_CTX_ST_READY] = "READY",
231 [SPOE_CTX_ST_ENCODING_MSGS] = "ENCODING_MSGS",
232 [SPOE_CTX_ST_SENDING_MSGS] = "SENDING_MSGS",
233 [SPOE_CTX_ST_WAITING_ACK] = "WAITING_ACK",
234 [SPOE_CTX_ST_DONE] = "DONE",
235 [SPOE_CTX_ST_ERROR] = "ERROR",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200236};
237
238static const char *spoe_appctx_state_str[SPOE_APPCTX_ST_END+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100239 [SPOE_APPCTX_ST_CONNECT] = "CONNECT",
240 [SPOE_APPCTX_ST_CONNECTING] = "CONNECTING",
241 [SPOE_APPCTX_ST_IDLE] = "IDLE",
242 [SPOE_APPCTX_ST_PROCESSING] = "PROCESSING",
243 [SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY] = "SENDING_FRAG_NOTIFY",
244 [SPOE_APPCTX_ST_WAITING_SYNC_ACK] = "WAITING_SYNC_ACK",
245 [SPOE_APPCTX_ST_DISCONNECT] = "DISCONNECT",
246 [SPOE_APPCTX_ST_DISCONNECTING] = "DISCONNECTING",
247 [SPOE_APPCTX_ST_EXIT] = "EXIT",
248 [SPOE_APPCTX_ST_END] = "END",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200249};
250
251#endif
Christopher Fauleta1cda022016-12-21 08:58:06 +0100252
Christopher Faulet8ef75252017-02-20 22:56:03 +0100253/* Used to generates a unique id for an engine. On success, it returns a
254 * allocated string. So it is the caller's reponsibility to release it. If the
255 * allocation failed, it returns NULL. */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100256static char *
257generate_pseudo_uuid()
258{
259 static int init = 0;
260
261 const char uuid_fmt[] = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
262 const char uuid_chr[] = "0123456789ABCDEF-";
263 char *uuid;
264 int i;
265
266 if ((uuid = calloc(1, sizeof(uuid_fmt))) == NULL)
267 return NULL;
268
269 if (!init) {
270 srand(now_ms);
271 init = 1;
272 }
273
274 for (i = 0; i < sizeof(uuid_fmt)-1; i++) {
275 int r = rand () % 16;
276
277 switch (uuid_fmt[i]) {
278 case 'x' : uuid[i] = uuid_chr[r]; break;
279 case 'y' : uuid[i] = uuid_chr[(r & 0x03) | 0x08]; break;
280 default : uuid[i] = uuid_fmt[i]; break;
281 }
282 }
283 return uuid;
284}
285
Christopher Fauletb2dd1e02018-03-22 09:07:41 +0100286
287static inline void
288spoe_update_stat_time(struct timeval *tv, long *t)
289{
290 if (*t == -1)
291 *t = tv_ms_elapsed(tv, &now);
292 else
293 *t += tv_ms_elapsed(tv, &now);
294 tv_zero(tv);
295}
296
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200297/********************************************************************
298 * Functions that encode/decode SPOE frames
299 ********************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200300/* Helper to get static string length, excluding the terminating null byte */
301#define SLEN(str) (sizeof(str)-1)
302
303/* Predefined key used in HELLO/DISCONNECT frames */
304#define SUPPORTED_VERSIONS_KEY "supported-versions"
305#define VERSION_KEY "version"
306#define MAX_FRAME_SIZE_KEY "max-frame-size"
307#define CAPABILITIES_KEY "capabilities"
Christopher Fauleta1cda022016-12-21 08:58:06 +0100308#define ENGINE_ID_KEY "engine-id"
Christopher Fauletba7bc162016-11-07 21:07:38 +0100309#define HEALTHCHECK_KEY "healthcheck"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200310#define STATUS_CODE_KEY "status-code"
311#define MSG_KEY "message"
312
313struct spoe_version {
314 char *str;
315 int min;
316 int max;
317};
318
319/* All supported versions */
320static struct spoe_version supported_versions[] = {
Christopher Faulet63816502018-05-31 14:56:42 +0200321 /* 1.0 is now unsupported because of a bug about frame's flags*/
322 {"2.0", 2000, 2000},
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200323 {NULL, 0, 0}
324};
325
326/* Comma-separated list of supported versions */
Christopher Faulet63816502018-05-31 14:56:42 +0200327#define SUPPORTED_VERSIONS_VAL "2.0"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200328
Christopher Faulet8ef75252017-02-20 22:56:03 +0100329/* Convert a string to a SPOE version value. The string must follow the format
330 * "MAJOR.MINOR". It will be concerted into the integer (1000 * MAJOR + MINOR).
331 * If an error occurred, -1 is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200332static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100333spoe_str_to_vsn(const char *str, size_t len)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200334{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100335 const char *p, *end;
336 int maj, min, vsn;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200337
Christopher Faulet8ef75252017-02-20 22:56:03 +0100338 p = str;
339 end = str+len;
340 maj = min = 0;
341 vsn = -1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200342
Christopher Faulet8ef75252017-02-20 22:56:03 +0100343 /* skip leading spaces */
344 while (p < end && isspace(*p))
345 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200346
Christopher Faulet8ef75252017-02-20 22:56:03 +0100347 /* parse Major number, until the '.' */
348 while (*p != '.') {
349 if (p >= end || *p < '0' || *p > '9')
350 goto out;
351 maj *= 10;
352 maj += (*p - '0');
353 p++;
354 }
355
356 /* check Major version */
357 if (!maj)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200358 goto out;
359
Christopher Faulet8ef75252017-02-20 22:56:03 +0100360 p++; /* skip the '.' */
361 if (p >= end || *p < '0' || *p > '9') /* Minor number is missing */
362 goto out;
363
364 /* Parse Minor number */
365 while (p < end) {
366 if (*p < '0' || *p > '9')
367 break;
368 min *= 10;
369 min += (*p - '0');
370 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200371 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100372
373 /* check Minor number */
374 if (min > 999)
375 goto out;
376
377 /* skip trailing spaces */
378 while (p < end && isspace(*p))
379 p++;
380 if (p != end)
381 goto out;
382
383 vsn = maj * 1000 + min;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200384 out:
385 return vsn;
386}
387
Christopher Faulet8ef75252017-02-20 22:56:03 +0100388/* Encode the HELLO frame sent by HAProxy to an agent. It returns the number of
Joseph Herlantf7f60312018-11-15 13:46:49 -0800389 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
Christopher Faulet8ef75252017-02-20 22:56:03 +0100390 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200391static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100392spoe_prepare_hahello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200393{
Willy Tarreau83061a82018-07-13 11:56:34 +0200394 struct buffer *chk;
Christopher Faulet42bfa462017-01-04 14:14:19 +0100395 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100396 char *p, *end;
397 unsigned int flags = SPOE_FRM_FL_FIN;
398 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200399
Christopher Faulet8ef75252017-02-20 22:56:03 +0100400 p = frame;
401 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200402
Christopher Faulet8ef75252017-02-20 22:56:03 +0100403 /* Set Frame type */
404 *p++ = SPOE_FRM_T_HAPROXY_HELLO;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200405
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100406 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200407 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100408 memcpy(p, (char *)&flags, 4);
409 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200410
411 /* No stream-id and frame-id for HELLO frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100412 *p++ = 0; *p++ = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200413
414 /* There are 3 mandatory items: "supported-versions", "max-frame-size"
415 * and "capabilities" */
416
417 /* "supported-versions" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100418 sz = SLEN(SUPPORTED_VERSIONS_KEY);
419 if (spoe_encode_buffer(SUPPORTED_VERSIONS_KEY, sz, &p, end) == -1)
420 goto too_big;
421
422 *p++ = SPOE_DATA_T_STR;
423 sz = SLEN(SUPPORTED_VERSIONS_VAL);
424 if (spoe_encode_buffer(SUPPORTED_VERSIONS_VAL, sz, &p, end) == -1)
425 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200426
427 /* "max-fram-size" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100428 sz = SLEN(MAX_FRAME_SIZE_KEY);
429 if (spoe_encode_buffer(MAX_FRAME_SIZE_KEY, sz, &p, end) == -1)
430 goto too_big;
431
432 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200433 if (encode_varint(SPOE_APPCTX(appctx)->max_frame_size, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100434 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200435
436 /* "capabilities" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100437 sz = SLEN(CAPABILITIES_KEY);
438 if (spoe_encode_buffer(CAPABILITIES_KEY, sz, &p, end) == -1)
439 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200440
Christopher Faulet8ef75252017-02-20 22:56:03 +0100441 *p++ = SPOE_DATA_T_STR;
Christopher Faulet305c6072017-02-23 16:17:53 +0100442 chk = get_trash_chunk();
443 if (agent != NULL && (agent->flags & SPOE_FL_PIPELINING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200444 memcpy(chk->area, "pipelining", 10);
445 chk->data += 10;
Christopher Faulet305c6072017-02-23 16:17:53 +0100446 }
447 if (agent != NULL && (agent->flags & SPOE_FL_ASYNC)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200448 if (chk->data) chk->area[chk->data++] = ',';
449 memcpy(chk->area+chk->data, "async", 5);
450 chk->data += 5;
Christopher Faulet305c6072017-02-23 16:17:53 +0100451 }
Christopher Fauletcecd8522017-02-24 22:11:21 +0100452 if (agent != NULL && (agent->flags & SPOE_FL_RCV_FRAGMENTATION)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200453 if (chk->data) chk->area[chk->data++] = ',';
454 memcpy(chk->area+chk->data, "fragmentation", 13);
Miroslav Zagorac6b3690b2019-01-13 16:55:01 +0100455 chk->data += 13;
Christopher Fauletcecd8522017-02-24 22:11:21 +0100456 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200457 if (spoe_encode_buffer(chk->area, chk->data, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100458 goto too_big;
459
460 /* (optionnal) "engine-id" K/V item, if present */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100461 if (agent != NULL && agent->engine_id != NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100462 sz = SLEN(ENGINE_ID_KEY);
463 if (spoe_encode_buffer(ENGINE_ID_KEY, sz, &p, end) == -1)
464 goto too_big;
465
466 *p++ = SPOE_DATA_T_STR;
467 sz = strlen(agent->engine_id);
468 if (spoe_encode_buffer(agent->engine_id, sz, &p, end) == -1)
469 goto too_big;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100470 }
471
Christopher Faulet8ef75252017-02-20 22:56:03 +0100472 return (p - frame);
473
474 too_big:
475 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
476 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200477}
478
Christopher Faulet8ef75252017-02-20 22:56:03 +0100479/* Encode DISCONNECT frame sent by HAProxy to an agent. It returns the number of
480 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
481 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200482static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100483spoe_prepare_hadiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200484{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100485 const char *reason;
486 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100487 unsigned int flags = SPOE_FRM_FL_FIN;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100488 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200489
Christopher Faulet8ef75252017-02-20 22:56:03 +0100490 p = frame;
491 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200492
Christopher Faulet8ef75252017-02-20 22:56:03 +0100493 /* Set Frame type */
494 *p++ = SPOE_FRM_T_HAPROXY_DISCON;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200495
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100496 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200497 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100498 memcpy(p, (char *)&flags, 4);
499 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200500
501 /* No stream-id and frame-id for DISCONNECT frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100502 *p++ = 0; *p++ = 0;
503
504 if (SPOE_APPCTX(appctx)->status_code >= SPOE_FRM_ERRS)
505 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200506
507 /* There are 2 mandatory items: "status-code" and "message" */
508
509 /* "status-code" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100510 sz = SLEN(STATUS_CODE_KEY);
511 if (spoe_encode_buffer(STATUS_CODE_KEY, sz, &p, end) == -1)
512 goto too_big;
513
514 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200515 if (encode_varint(SPOE_APPCTX(appctx)->status_code, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100516 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200517
518 /* "message" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100519 sz = SLEN(MSG_KEY);
520 if (spoe_encode_buffer(MSG_KEY, sz, &p, end) == -1)
521 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200522
Christopher Faulet8ef75252017-02-20 22:56:03 +0100523 /*Get the message corresponding to the status code */
524 reason = spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code];
525
526 *p++ = SPOE_DATA_T_STR;
527 sz = strlen(reason);
528 if (spoe_encode_buffer(reason, sz, &p, end) == -1)
529 goto too_big;
530
531 return (p - frame);
532
533 too_big:
534 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
535 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200536}
537
Christopher Faulet8ef75252017-02-20 22:56:03 +0100538/* Encode the NOTIFY frame sent by HAProxy to an agent. It returns the number of
539 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
540 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200541static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100542spoe_prepare_hanotify_frame(struct appctx *appctx, struct spoe_context *ctx,
Christopher Fauleta1cda022016-12-21 08:58:06 +0100543 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200544{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100545 char *p, *end;
546 unsigned int stream_id, frame_id;
547 unsigned int flags = SPOE_FRM_FL_FIN;
548 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200549
Christopher Faulet8ef75252017-02-20 22:56:03 +0100550 p = frame;
551 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200552
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100553 stream_id = ctx->stream_id;
554 frame_id = ctx->frame_id;
555
556 if (ctx->flags & SPOE_CTX_FL_FRAGMENTED) {
557 /* The fragmentation is not supported by the applet */
558 if (!(SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_FRAGMENTATION)) {
559 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
560 return -1;
561 }
562 flags = ctx->frag_ctx.flags;
563 }
564
565 /* Set Frame type */
566 *p++ = SPOE_FRM_T_HAPROXY_NOTIFY;
567
568 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200569 flags = htonl(flags);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100570 memcpy(p, (char *)&flags, 4);
571 p += 4;
572
573 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200574 if (encode_varint(stream_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100575 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200576 if (encode_varint(frame_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100577 goto too_big;
578
579 /* Copy encoded messages, if possible */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200580 sz = b_data(&ctx->buffer);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100581 if (p + sz >= end)
582 goto too_big;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200583 memcpy(p, b_head(&ctx->buffer), sz);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100584 p += sz;
585
586 return (p - frame);
587
588 too_big:
589 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
590 return 0;
591}
592
593/* Encode next part of a fragmented frame sent by HAProxy to an agent. It
594 * returns the number of encoded bytes in the frame on success, 0 if an encoding
595 * error occurred and -1 if a fatal error occurred. */
596static int
597spoe_prepare_hafrag_frame(struct appctx *appctx, struct spoe_context *ctx,
598 char *frame, size_t size)
599{
600 char *p, *end;
601 unsigned int stream_id, frame_id;
602 unsigned int flags;
603 size_t sz;
604
605 p = frame;
606 end = frame+size;
607
Christopher Faulet8ef75252017-02-20 22:56:03 +0100608 /* <ctx> is null when the stream has aborted the processing of a
609 * fragmented frame. In this case, we must notify the corresponding
610 * agent using ids stored in <frag_ctx>. */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100611 if (ctx == NULL) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100612 flags = (SPOE_FRM_FL_FIN|SPOE_FRM_FL_ABRT);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100613 stream_id = SPOE_APPCTX(appctx)->frag_ctx.cursid;
614 frame_id = SPOE_APPCTX(appctx)->frag_ctx.curfid;
615 }
616 else {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100617 flags = ctx->frag_ctx.flags;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100618 stream_id = ctx->stream_id;
619 frame_id = ctx->frame_id;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100620 }
621
Christopher Faulet8ef75252017-02-20 22:56:03 +0100622 /* Set Frame type */
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100623 *p++ = SPOE_FRM_T_UNSET;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100624
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100625 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200626 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100627 memcpy(p, (char *)&flags, 4);
628 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200629
630 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200631 if (encode_varint(stream_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100632 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200633 if (encode_varint(frame_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100634 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200635
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100636 if (ctx == NULL)
637 goto end;
638
Christopher Faulet8ef75252017-02-20 22:56:03 +0100639 /* Copy encoded messages, if possible */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200640 sz = b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100641 if (p + sz >= end)
642 goto too_big;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200643 memcpy(p, b_head(&ctx->buffer), sz);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100644 p += sz;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100645
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100646 end:
Christopher Faulet8ef75252017-02-20 22:56:03 +0100647 return (p - frame);
648
649 too_big:
650 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
651 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200652}
653
Christopher Faulet8ef75252017-02-20 22:56:03 +0100654/* Decode and process the HELLO frame sent by an agent. It returns the number of
655 * read bytes on success, 0 if a decoding error occurred, and -1 if a fatal
656 * error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200657static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100658spoe_handle_agenthello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200659{
Christopher Faulet305c6072017-02-23 16:17:53 +0100660 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
661 char *p, *end;
662 int vsn, max_frame_size;
663 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100664
665 p = frame;
666 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200667
668 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100669 if (*p++ != SPOE_FRM_T_AGENT_HELLO) {
670 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200671 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100672 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200673
Christopher Faulet8ef75252017-02-20 22:56:03 +0100674 if (size < 7 /* TYPE + METADATA */) {
675 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
676 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200677 }
678
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100679 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100680 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200681 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100682 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200683
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100684 /* Fragmentation is not supported for HELLO frame */
685 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100686 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100687 return -1;
688 }
689
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200690 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100691 if (*p != 0 || *(p+1) != 0) {
692 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
693 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200694 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100695 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200696
697 /* There are 3 mandatory items: "version", "max-frame-size" and
698 * "capabilities" */
699
700 /* Loop on K/V items */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100701 vsn = max_frame_size = flags = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100702 while (p < end) {
703 char *str;
Frédéric Lécaille6ca71a92017-08-22 10:33:14 +0200704 uint64_t sz;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100705 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200706
707 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100708 ret = spoe_decode_buffer(&p, end, &str, &sz);
709 if (ret == -1 || !sz) {
710 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
711 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200712 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100713
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200714 /* Check "version" K/V item */
715 if (!memcmp(str, VERSION_KEY, sz)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100716 int i, type = *p++;
717
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200718 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100719 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
720 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
721 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200722 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100723 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
724 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
725 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200726 }
727
Christopher Faulet8ef75252017-02-20 22:56:03 +0100728 vsn = spoe_str_to_vsn(str, sz);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200729 if (vsn == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100730 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200731 return -1;
732 }
733 for (i = 0; supported_versions[i].str != NULL; ++i) {
734 if (vsn >= supported_versions[i].min &&
735 vsn <= supported_versions[i].max)
736 break;
737 }
738 if (supported_versions[i].str == NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100739 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200740 return -1;
741 }
742 }
743 /* Check "max-frame-size" K/V item */
744 else if (!memcmp(str, MAX_FRAME_SIZE_KEY, sz)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100745 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200746
747 /* The value must be integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200748 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
749 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
750 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
751 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100752 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
753 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200754 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200755 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100756 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
757 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200758 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100759 if (sz < MIN_FRAME_SIZE ||
760 sz > SPOE_APPCTX(appctx)->max_frame_size) {
761 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200762 return -1;
763 }
764 max_frame_size = sz;
765 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100766 /* Check "capabilities" K/V item */
767 else if (!memcmp(str, CAPABILITIES_KEY, sz)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100768 int type = *p++;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100769
770 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100771 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
772 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
773 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100774 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100775 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
776 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
777 return 0;
778 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100779
Christopher Faulet8ef75252017-02-20 22:56:03 +0100780 while (sz) {
Christopher Fauleta1cda022016-12-21 08:58:06 +0100781 char *delim;
782
783 /* Skip leading spaces */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100784 for (; isspace(*str) && sz; str++, sz--);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100785
Christopher Faulet8ef75252017-02-20 22:56:03 +0100786 if (sz >= 10 && !strncmp(str, "pipelining", 10)) {
787 str += 10; sz -= 10;
788 if (!sz || isspace(*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100789 flags |= SPOE_APPCTX_FL_PIPELINING;
790 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100791 else if (sz >= 5 && !strncmp(str, "async", 5)) {
792 str += 5; sz -= 5;
793 if (!sz || isspace(*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100794 flags |= SPOE_APPCTX_FL_ASYNC;
795 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100796 else if (sz >= 13 && !strncmp(str, "fragmentation", 13)) {
797 str += 13; sz -= 13;
798 if (!sz || isspace(*str) || *str == ',')
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100799 flags |= SPOE_APPCTX_FL_FRAGMENTATION;
800 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100801
Christopher Faulet8ef75252017-02-20 22:56:03 +0100802 /* Get the next comma or break */
803 if (!sz || (delim = memchr(str, ',', sz)) == NULL)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100804 break;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100805 delim++;
806 sz -= (delim - str);
807 str = delim;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100808 }
809 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200810 else {
811 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100812 if (spoe_skip_data(&p, end) == -1) {
813 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
814 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200815 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200816 }
817 }
818
819 /* Final checks */
820 if (!vsn) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100821 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200822 return -1;
823 }
824 if (!max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100825 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200826 return -1;
827 }
Christopher Faulet11389012019-02-07 16:13:26 +0100828 if (!agent)
829 flags &= ~(SPOE_APPCTX_FL_PIPELINING|SPOE_APPCTX_FL_ASYNC);
830 else {
831 if ((flags & SPOE_APPCTX_FL_PIPELINING) && !(agent->flags & SPOE_FL_PIPELINING))
832 flags &= ~SPOE_APPCTX_FL_PIPELINING;
833 if ((flags & SPOE_APPCTX_FL_ASYNC) && !(agent->flags & SPOE_FL_ASYNC))
834 flags &= ~SPOE_APPCTX_FL_ASYNC;
835 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200836
Christopher Faulet42bfa462017-01-04 14:14:19 +0100837 SPOE_APPCTX(appctx)->version = (unsigned int)vsn;
838 SPOE_APPCTX(appctx)->max_frame_size = (unsigned int)max_frame_size;
839 SPOE_APPCTX(appctx)->flags |= flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100840
841 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200842}
843
844/* Decode DISCONNECT frame sent by an agent. It returns the number of by read
845 * bytes on success, 0 if the frame can be ignored and -1 if an error
846 * occurred. */
847static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100848spoe_handle_agentdiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200849{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100850 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100851 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100852
853 p = frame;
854 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200855
856 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100857 if (*p++ != SPOE_FRM_T_AGENT_DISCON) {
858 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200859 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100860 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200861
Christopher Faulet8ef75252017-02-20 22:56:03 +0100862 if (size < 7 /* TYPE + METADATA */) {
863 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
864 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200865 }
866
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100867 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100868 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200869 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100870 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200871
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100872 /* Fragmentation is not supported for DISCONNECT frame */
873 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100874 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100875 return -1;
876 }
877
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200878 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100879 if (*p != 0 || *(p+1) != 0) {
880 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
881 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200882 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100883 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200884
885 /* There are 2 mandatory items: "status-code" and "message" */
886
887 /* Loop on K/V items */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100888 while (p < end) {
889 char *str;
Frédéric Lécaille6ca71a92017-08-22 10:33:14 +0200890 uint64_t sz;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100891 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200892
893 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100894 ret = spoe_decode_buffer(&p, end, &str, &sz);
895 if (ret == -1 || !sz) {
896 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
897 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200898 }
899
900 /* Check "status-code" K/V item */
901 if (!memcmp(str, STATUS_CODE_KEY, sz)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100902 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200903
904 /* The value must be an integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200905 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
906 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
907 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
908 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100909 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
910 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200911 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200912 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100913 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
914 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200915 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100916 SPOE_APPCTX(appctx)->status_code = sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200917 }
918
919 /* Check "message" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100920 else if (!memcmp(str, MSG_KEY, sz)) {
921 int type = *p++;
922
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200923 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100924 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
925 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
926 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200927 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100928 ret = spoe_decode_buffer(&p, end, &str, &sz);
929 if (ret == -1 || sz > 255) {
930 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
931 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200932 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100933#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
934 SPOE_APPCTX(appctx)->reason = str;
935 SPOE_APPCTX(appctx)->rlen = sz;
936#endif
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200937 }
938 else {
939 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100940 if (spoe_skip_data(&p, end) == -1) {
941 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
942 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200943 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200944 }
945 }
946
Christopher Faulet8ef75252017-02-20 22:56:03 +0100947 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200948}
949
950
Christopher Fauleta1cda022016-12-21 08:58:06 +0100951/* Decode ACK frame sent by an agent. It returns the number of read bytes on
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200952 * success, 0 if the frame can be ignored and -1 if an error occurred. */
953static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100954spoe_handle_agentack_frame(struct appctx *appctx, struct spoe_context **ctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100955 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200956{
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100957 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100958 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100959 uint64_t stream_id, frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100960 int len;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100961 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100962
963 p = frame;
964 end = frame + size;
965 *ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200966
967 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100968 if (*p++ != SPOE_FRM_T_AGENT_ACK) {
969 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200970 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100971 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200972
Christopher Faulet8ef75252017-02-20 22:56:03 +0100973 if (size < 7 /* TYPE + METADATA */) {
974 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
975 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200976 }
977
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100978 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100979 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200980 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100981 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200982
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100983 /* Fragmentation is not supported for now */
984 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100985 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100986 return -1;
987 }
988
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200989 /* Get the stream-id and the frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200990 if (decode_varint(&p, end, &stream_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100991 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100992 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100993 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200994 if (decode_varint(&p, end, &frame_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100995 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200996 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100997 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100998
Christopher Faulet8ef75252017-02-20 22:56:03 +0100999 /* Try to find the corresponding SPOE context */
Christopher Faulet42bfa462017-01-04 14:14:19 +01001000 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
Christopher Faulet24289f22017-09-25 14:48:02 +02001001 list_for_each_entry((*ctx), &agent->rt[tid].waiting_queue, list) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001002 if ((*ctx)->stream_id == (unsigned int)stream_id &&
1003 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001004 goto found;
1005 }
1006 }
1007 else {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001008 list_for_each_entry((*ctx), &SPOE_APPCTX(appctx)->waiting_queue, list) {
1009 if ((*ctx)->stream_id == (unsigned int)stream_id &&
Christopher Faulet8ef75252017-02-20 22:56:03 +01001010 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001011 goto found;
1012 }
1013 }
1014
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001015 if (SPOE_APPCTX(appctx)->frag_ctx.ctx &&
1016 SPOE_APPCTX(appctx)->frag_ctx.cursid == (unsigned int)stream_id &&
1017 SPOE_APPCTX(appctx)->frag_ctx.curfid == (unsigned int)frame_id) {
1018
1019 /* ABRT bit is set for an unfinished fragmented frame */
1020 if (flags & SPOE_FRM_FL_ABRT) {
1021 *ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001022 (*ctx)->state = SPOE_CTX_ST_ERROR;
1023 (*ctx)->status_code = SPOE_CTX_ERR_FRAG_FRAME_ABRT;
1024 /* Ignore the payload */
1025 goto end;
1026 }
1027 /* TODO: Handle more flags for fragmented frames: RESUME, FINISH... */
1028 /* For now, we ignore the ack */
1029 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
1030 return 0;
1031 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001032
Christopher Fauleta1cda022016-12-21 08:58:06 +01001033 /* No Stream found, ignore the frame */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001034 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1035 " - Ignore ACK frame"
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001036 " - stream-id=%u - frame-id=%u\n",
1037 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1038 __FUNCTION__, appctx,
1039 (unsigned int)stream_id, (unsigned int)frame_id);
1040
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001041 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAMEID_NOTFOUND;
Christopher Faulet3a47e5e2018-05-25 10:42:37 +02001042 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1043 return -1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001044 return 0;
1045
1046 found:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001047 if (!spoe_acquire_buffer(&SPOE_APPCTX(appctx)->buffer,
1048 &SPOE_APPCTX(appctx)->buffer_wait)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001049 *ctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001050 return 1; /* Retry later */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001051 }
Christopher Faulet4596fb72017-01-11 14:05:19 +01001052
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001053 /* Copy encoded actions */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001054 len = (end - p);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001055 memcpy(b_head(&SPOE_APPCTX(appctx)->buffer), p, len);
1056 b_set_data(&SPOE_APPCTX(appctx)->buffer, len);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001057 p += len;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001058
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001059 /* Transfer the buffer ownership to the SPOE context */
1060 (*ctx)->buffer = SPOE_APPCTX(appctx)->buffer;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001061 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001062
Christopher Faulet8ef75252017-02-20 22:56:03 +01001063 (*ctx)->state = SPOE_CTX_ST_DONE;
1064
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001065 end:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001066 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001067 " - ACK frame received"
1068 " - ctx=%p - stream-id=%u - frame-id=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001069 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001070 __FUNCTION__, appctx, *ctx, (*ctx)->stream_id,
1071 (*ctx)->frame_id, flags);
1072 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001073}
1074
Christopher Fauletba7bc162016-11-07 21:07:38 +01001075/* This function is used in cfgparse.c and declared in proto/checks.h. It
1076 * prepare the request to send to agents during a healthcheck. It returns 0 on
1077 * success and -1 if an error occurred. */
1078int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001079spoe_prepare_healthcheck_request(char **req, int *len)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001080{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001081 struct appctx appctx;
1082 struct spoe_appctx spoe_appctx;
1083 char *frame, *end, buf[MAX_FRAME_SIZE+4];
1084 size_t sz;
1085 int ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001086
Christopher Faulet42bfa462017-01-04 14:14:19 +01001087 memset(&appctx, 0, sizeof(appctx));
1088 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001089 memset(buf, 0, sizeof(buf));
Christopher Faulet42bfa462017-01-04 14:14:19 +01001090
1091 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001092 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001093
Christopher Faulet8ef75252017-02-20 22:56:03 +01001094 frame = buf+4; /* Reserved the 4 first bytes for the frame size */
1095 end = frame + MAX_FRAME_SIZE;
1096
1097 ret = spoe_prepare_hahello_frame(&appctx, frame, MAX_FRAME_SIZE);
1098 if (ret <= 0)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001099 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001100 frame += ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001101
Christopher Faulet8ef75252017-02-20 22:56:03 +01001102 /* Add "healthcheck" K/V item */
1103 sz = SLEN(HEALTHCHECK_KEY);
1104 if (spoe_encode_buffer(HEALTHCHECK_KEY, sz, &frame, end) == -1)
1105 return -1;
1106 *frame++ = (SPOE_DATA_T_BOOL | SPOE_DATA_FL_TRUE);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001107
Christopher Faulet8ef75252017-02-20 22:56:03 +01001108 *len = frame - buf;
1109 sz = htonl(*len - 4);
1110 memcpy(buf, (char *)&sz, 4);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001111
Christopher Faulet8ef75252017-02-20 22:56:03 +01001112 if ((*req = malloc(*len)) == NULL)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001113 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001114 memcpy(*req, buf, *len);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001115 return 0;
1116}
1117
1118/* This function is used in checks.c and declared in proto/checks.h. It decode
1119 * the response received from an agent during a healthcheck. It returns 0 on
1120 * success and -1 if an error occurred. */
1121int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001122spoe_handle_healthcheck_response(char *frame, size_t size, char *err, int errlen)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001123{
Christopher Faulet42bfa462017-01-04 14:14:19 +01001124 struct appctx appctx;
1125 struct spoe_appctx spoe_appctx;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001126
Christopher Faulet42bfa462017-01-04 14:14:19 +01001127 memset(&appctx, 0, sizeof(appctx));
1128 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001129
Christopher Faulet42bfa462017-01-04 14:14:19 +01001130 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001131 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001132
Christopher Faulet8ef75252017-02-20 22:56:03 +01001133 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1134 spoe_handle_agentdiscon_frame(&appctx, frame, size);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001135 goto error;
1136 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001137 if (spoe_handle_agenthello_frame(&appctx, frame, size) <= 0)
1138 goto error;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001139
1140 return 0;
1141
1142 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001143 if (SPOE_APPCTX(&appctx)->status_code >= SPOE_FRM_ERRS)
1144 SPOE_APPCTX(&appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
1145 strncpy(err, spoe_frm_err_reasons[SPOE_APPCTX(&appctx)->status_code], errlen);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001146 return -1;
1147}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001148
Christopher Fauleta1cda022016-12-21 08:58:06 +01001149/* Send a SPOE frame to an agent. It returns -1 when an error occurred, 0 when
1150 * the frame can be ignored, 1 to retry later, and the frame legnth on
1151 * success. */
1152static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001153spoe_send_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001154{
1155 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001156 int ret;
1157 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001158
Christopher Faulet8ef75252017-02-20 22:56:03 +01001159 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1160 * length. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001161 netint = htonl(framesz);
1162 memcpy(buf, (char *)&netint, 4);
Willy Tarreau06d80a92017-10-19 14:32:15 +02001163 ret = ci_putblk(si_ic(si), buf, framesz+4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001164 if (ret <= 0) {
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001165 if ((ret == -3 && b_is_null(&si_ic(si)->buf)) || ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001166 si_rx_room_blk(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001167 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001168 }
1169 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001170 return -1; /* error */
1171 }
1172 return framesz;
1173}
1174
1175/* Receive a SPOE frame from an agent. It return -1 when an error occurred, 0
1176 * when the frame can be ignored, 1 to retry later and the frame length on
1177 * success. */
1178static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001179spoe_recv_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001180{
1181 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001182 int ret;
1183 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001184
Willy Tarreau06d80a92017-10-19 14:32:15 +02001185 ret = co_getblk(si_oc(si), (char *)&netint, 4, 0);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001186 if (ret > 0) {
1187 framesz = ntohl(netint);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001188 if (framesz > SPOE_APPCTX(appctx)->max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001189 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001190 return -1;
1191 }
Willy Tarreau06d80a92017-10-19 14:32:15 +02001192 ret = co_getblk(si_oc(si), buf, framesz, 4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001193 }
1194 if (ret <= 0) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001195 if (ret == 0) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001196 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001197 }
1198 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001199 return -1; /* error */
1200 }
1201 return framesz;
1202}
1203
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001204/********************************************************************
1205 * Functions that manage the SPOE applet
1206 ********************************************************************/
Christopher Faulet4596fb72017-01-11 14:05:19 +01001207static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001208spoe_wakeup_appctx(struct appctx *appctx)
Christopher Faulet4596fb72017-01-11 14:05:19 +01001209{
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001210 si_want_get(appctx->owner);
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001211 si_rx_endp_more(appctx->owner);
Christopher Faulet4596fb72017-01-11 14:05:19 +01001212 appctx_wakeup(appctx);
1213 return 1;
1214}
1215
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001216/* Callback function that catches applet timeouts. If a timeout occurred, we set
1217 * <appctx->st1> flag and the SPOE applet is woken up. */
1218static struct task *
Olivier Houchard9f6af332018-05-25 14:04:04 +02001219spoe_process_appctx(struct task * task, void *context, unsigned short state)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001220{
Olivier Houchard9f6af332018-05-25 14:04:04 +02001221 struct appctx *appctx = context;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001222
1223 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1224 if (tick_is_expired(task->expire, now_ms)) {
1225 task->expire = TICK_ETERNITY;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001226 appctx->st1 = SPOE_APPCTX_ERR_TOUT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001227 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001228 spoe_wakeup_appctx(appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001229 return task;
1230}
1231
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001232/* Callback function that releases a SPOE applet. This happens when the
1233 * connection with the agent is closed. */
1234static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001235spoe_release_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001236{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001237 struct stream_interface *si = appctx->owner;
1238 struct spoe_appctx *spoe_appctx = SPOE_APPCTX(appctx);
1239 struct spoe_agent *agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001240 struct spoe_context *ctx, *back;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001241
1242 if (spoe_appctx == NULL)
1243 return;
1244
1245 appctx->ctx.spoe.ptr = NULL;
1246 agent = spoe_appctx->agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001247
1248 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p\n",
1249 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1250 __FUNCTION__, appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001251
Christopher Faulet8ef75252017-02-20 22:56:03 +01001252 /* Remove applet from the list of running applets */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001253 _HA_ATOMIC_SUB(&agent->counters.applets, 1);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001254 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001255 if (!LIST_ISEMPTY(&spoe_appctx->list)) {
1256 LIST_DEL(&spoe_appctx->list);
1257 LIST_INIT(&spoe_appctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001258 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001259 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001260
Christopher Faulet8ef75252017-02-20 22:56:03 +01001261 /* Shutdown the server connection, if needed */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001262 if (appctx->st0 != SPOE_APPCTX_ST_END) {
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001263 if (appctx->st0 == SPOE_APPCTX_ST_IDLE) {
1264 eb32_delete(&spoe_appctx->node);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001265 _HA_ATOMIC_SUB(&agent->counters.idles, 1);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001266 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001267
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001268 appctx->st0 = SPOE_APPCTX_ST_END;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001269 if (spoe_appctx->status_code == SPOE_FRM_ERR_NONE)
1270 spoe_appctx->status_code = SPOE_FRM_ERR_IO;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001271
1272 si_shutw(si);
1273 si_shutr(si);
1274 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001275 }
1276
Christopher Faulet8ef75252017-02-20 22:56:03 +01001277 /* Destroy the task attached to this applet */
Willy Tarreauf6562792019-05-07 19:05:35 +02001278 task_destroy(spoe_appctx->task);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001279
Christopher Faulet8ef75252017-02-20 22:56:03 +01001280 /* Notify all waiting streams */
1281 list_for_each_entry_safe(ctx, back, &spoe_appctx->waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001282 LIST_DEL(&ctx->list);
1283 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001284 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001285 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001286 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001287 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001288 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001289 }
1290
Christopher Faulet8ef75252017-02-20 22:56:03 +01001291 /* If the applet was processing a fragmented frame, notify the
1292 * corresponding stream. */
1293 if (spoe_appctx->frag_ctx.ctx) {
1294 ctx = spoe_appctx->frag_ctx.ctx;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001295 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001296 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001297 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001298 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1299 }
1300
Christopher Faulet24289f22017-09-25 14:48:02 +02001301 if (!LIST_ISEMPTY(&agent->rt[tid].applets))
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001302 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001303
Christopher Faulet8ef75252017-02-20 22:56:03 +01001304 /* If this was the last running applet, notify all waiting streams */
Christopher Faulet24289f22017-09-25 14:48:02 +02001305 list_for_each_entry_safe(ctx, back, &agent->rt[tid].sending_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001306 LIST_DEL(&ctx->list);
1307 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001308 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001309 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001310 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001311 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001312 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001313 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001314 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001315 LIST_DEL(&ctx->list);
1316 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001317 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001318 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001319 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001320 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001321 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1322 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001323
1324 end:
Christopher Faulet55ae8a62019-05-23 22:47:48 +02001325 /* Release allocated memory */
1326 spoe_release_buffer(&spoe_appctx->buffer,
1327 &spoe_appctx->buffer_wait);
1328 pool_free(pool_head_spoe_appctx, spoe_appctx);
1329
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001330 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001331 agent->rt[tid].frame_size = agent->max_frame_size;
1332 list_for_each_entry(spoe_appctx, &agent->rt[tid].applets, list)
1333 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, spoe_appctx->max_frame_size);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001334}
1335
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001336static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001337spoe_handle_connect_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001338{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001339 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001340 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001341 char *frame, *buf;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001342 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001343
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001344 if (si_state_in(si->state, SI_SB_CER|SI_SB_DIS|SI_SB_CLO)) {
1345 /* closed */
1346 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1347 goto exit;
1348 }
1349
Willy Tarreau4f283fa2019-06-05 14:34:03 +02001350 if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST)) {
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001351 /* not connected yet */
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001352 si_rx_endp_more(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001353 task_wakeup(si_strm(si)->task, TASK_WOKEN_MSG);
1354 goto stop;
1355 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001356
Christopher Fauleta1cda022016-12-21 08:58:06 +01001357 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001358 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1359 " - Connection timed out\n",
1360 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1361 __FUNCTION__, appctx);
1362 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001363 goto exit;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001364 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001365
Christopher Faulet42bfa462017-01-04 14:14:19 +01001366 if (SPOE_APPCTX(appctx)->task->expire == TICK_ETERNITY)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001367 SPOE_APPCTX(appctx)->task->expire =
1368 tick_add_ifset(now_ms, agent->timeout.hello);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001369
Christopher Faulet8ef75252017-02-20 22:56:03 +01001370 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1371 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001372 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001373 ret = spoe_prepare_hahello_frame(appctx, frame,
1374 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001375 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001376 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001377
1378 switch (ret) {
1379 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001380 case 0: /* ignore => an error, cannot be ignored */
1381 goto exit;
1382
1383 case 1: /* retry later */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001384 goto stop;
1385
Christopher Faulet8ef75252017-02-20 22:56:03 +01001386 default:
1387 /* HELLO frame successfully sent, now wait for the
1388 * reply. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001389 appctx->st0 = SPOE_APPCTX_ST_CONNECTING;
1390 goto next;
1391 }
1392
1393 next:
1394 return 0;
1395 stop:
1396 return 1;
1397 exit:
1398 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1399 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001400}
1401
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001402static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001403spoe_handle_connecting_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001404{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001405 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001406 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001407 char *frame;
1408 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001409
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001410
Christopher Fauletb067b062017-01-04 16:39:11 +01001411 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001412 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001413 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001414 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001415
Christopher Fauleta1cda022016-12-21 08:58:06 +01001416 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001417 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1418 " - Connection timed out\n",
1419 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1420 __FUNCTION__, appctx);
1421 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001422 goto exit;
1423 }
1424
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001425 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001426 ret = spoe_recv_frame(appctx, frame,
1427 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001428 if (ret > 1) {
1429 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1430 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1431 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001432 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001433 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001434 ret = spoe_handle_agenthello_frame(appctx, frame, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001435 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001436
Christopher Fauleta1cda022016-12-21 08:58:06 +01001437 switch (ret) {
1438 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001439 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001440 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1441 goto next;
1442
1443 case 1: /* retry later */
1444 goto stop;
1445
1446 default:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001447 /* HELLO handshake is finished, set the idle timeout and
1448 * add the applet in the list of running applets. */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001449 _HA_ATOMIC_ADD(&agent->counters.idles, 1);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001450 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001451 SPOE_APPCTX(appctx)->node.key = 0;
1452 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001453
1454 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001455 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001456 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001457 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001458
Christopher Fauleta1cda022016-12-21 08:58:06 +01001459 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001460 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001461 if (trash.data)
1462 co_skip(si_oc(si), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001463
1464 SPOE_APPCTX(appctx)->task->expire =
1465 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001466 return 0;
1467 stop:
1468 return 1;
1469 exit:
1470 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1471 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001472}
1473
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001474
Christopher Fauleta1cda022016-12-21 08:58:06 +01001475static int
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001476spoe_handle_sending_frame_appctx(struct appctx *appctx, int *skip)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001477{
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001478 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
1479 struct spoe_context *ctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001480 char *frame, *buf;
1481 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001482
Christopher Faulet8ef75252017-02-20 22:56:03 +01001483 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1484 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001485 buf = trash.area; frame = buf+4;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001486
1487 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY) {
1488 ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
1489 ret = spoe_prepare_hafrag_frame(appctx, ctx, frame,
1490 SPOE_APPCTX(appctx)->max_frame_size);
1491 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001492 else if (LIST_ISEMPTY(&agent->rt[tid].sending_queue)) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001493 *skip = 1;
1494 ret = 1;
1495 goto end;
1496 }
1497 else {
Christopher Faulet24289f22017-09-25 14:48:02 +02001498 ctx = LIST_NEXT(&agent->rt[tid].sending_queue, typeof(ctx), list);
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001499 ret = spoe_prepare_hanotify_frame(appctx, ctx, frame,
1500 SPOE_APPCTX(appctx)->max_frame_size);
1501
1502 }
1503
Christopher Faulet8ef75252017-02-20 22:56:03 +01001504 if (ret > 1)
1505 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001506
Christopher Faulet8ef75252017-02-20 22:56:03 +01001507 switch (ret) {
1508 case -1: /* error */
1509 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1510 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001511
Christopher Faulet8ef75252017-02-20 22:56:03 +01001512 case 0: /* ignore */
1513 if (ctx == NULL)
1514 goto abort_frag_frame;
1515
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001516 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001517 LIST_DEL(&ctx->list);
1518 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001519 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001520 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001521 ctx->spoe_appctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001522 ctx->state = SPOE_CTX_ST_ERROR;
1523 ctx->status_code = (SPOE_APPCTX(appctx)->status_code + 0x100);
1524 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001525 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001526 break;
1527
1528 case 1: /* retry */
1529 *skip = 1;
1530 break;
1531
1532 default:
1533 if (ctx == NULL)
1534 goto abort_frag_frame;
1535
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001536 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001537 LIST_DEL(&ctx->list);
1538 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001539 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001540 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001541 ctx->spoe_appctx = SPOE_APPCTX(appctx);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001542 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) ||
1543 (ctx->frag_ctx.flags & SPOE_FRM_FL_FIN))
1544 goto no_frag_frame_sent;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001545 else
Christopher Faulet8ef75252017-02-20 22:56:03 +01001546 goto frag_frame_sent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001547 }
1548 goto end;
1549
1550 frag_frame_sent:
1551 appctx->st0 = SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001552 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001553 SPOE_APPCTX(appctx)->frag_ctx.ctx = ctx;
1554 SPOE_APPCTX(appctx)->frag_ctx.cursid = ctx->stream_id;
1555 SPOE_APPCTX(appctx)->frag_ctx.curfid = ctx->frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001556 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
1557 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1558 goto end;
1559
1560 no_frag_frame_sent:
1561 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
1562 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet24289f22017-09-25 14:48:02 +02001563 LIST_ADDQ(&agent->rt[tid].waiting_queue, &ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001564 }
1565 else if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_PIPELINING) {
1566 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1567 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1568 }
1569 else {
1570 appctx->st0 = SPOE_APPCTX_ST_WAITING_SYNC_ACK;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001571 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001572 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1573 }
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001574 _HA_ATOMIC_ADD(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001575 ctx->stats.tv_wait = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001576 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1577 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1578 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001579 SPOE_APPCTX(appctx)->cur_fpa++;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001580
Christopher Faulet8ef75252017-02-20 22:56:03 +01001581 ctx->state = SPOE_CTX_ST_WAITING_ACK;
1582 goto end;
1583
1584 abort_frag_frame:
1585 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1586 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1587 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1588 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1589 goto end;
1590
1591 end:
1592 return ret;
1593}
1594
1595static int
1596spoe_handle_receiving_frame_appctx(struct appctx *appctx, int *skip)
1597{
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02001598 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001599 struct spoe_context *ctx = NULL;
1600 char *frame;
1601 int ret;
1602
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001603 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001604 ret = spoe_recv_frame(appctx, frame,
1605 SPOE_APPCTX(appctx)->max_frame_size);
1606 if (ret > 1) {
1607 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1608 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001609 ret = -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001610 goto end;
1611 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001612 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001613 ret = spoe_handle_agentack_frame(appctx, &ctx, frame, ret);
1614 }
1615 switch (ret) {
1616 case -1: /* error */
1617 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1618 break;
1619
1620 case 0: /* ignore */
1621 break;
1622
1623 case 1: /* retry */
1624 *skip = 1;
1625 break;
1626
1627 default:
1628 LIST_DEL(&ctx->list);
1629 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001630 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001631 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
1632 ctx->stats.tv_response = now;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001633 if (ctx->spoe_appctx) {
1634 ctx->spoe_appctx->cur_fpa--;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001635 ctx->spoe_appctx = NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001636 }
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001637 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY &&
1638 ctx == SPOE_APPCTX(appctx)->frag_ctx.ctx) {
1639 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1640 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1641 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1642 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1643 }
1644 else if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1645 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001646 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1647 break;
1648 }
1649
1650 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001651 if (trash.data)
1652 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001653 end:
1654 return ret;
1655}
1656
1657static int
1658spoe_handle_processing_appctx(struct appctx *appctx)
1659{
1660 struct stream_interface *si = appctx->owner;
1661 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001662 int ret, skip_sending = 0, skip_receiving = 0, active_s = 0, active_r = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001663
1664 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
1665 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1666 goto exit;
1667 }
1668
1669 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
1670 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
1671 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1672 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1673 goto next;
1674 }
1675
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001676 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001677 " - process: fpa=%u/%u - appctx-state=%s - weight=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001678 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8f82b202018-01-24 16:23:03 +01001679 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->cur_fpa,
1680 agent->max_fpa, spoe_appctx_state_str[appctx->st0],
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001681 SPOE_APPCTX(appctx)->node.key, SPOE_APPCTX(appctx)->flags);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001682
Christopher Faulet8f82b202018-01-24 16:23:03 +01001683 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1684 skip_sending = 1;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001685
Christopher Faulet8f82b202018-01-24 16:23:03 +01001686 /* receiving_frame loop */
1687 while (!skip_receiving) {
1688 ret = spoe_handle_receiving_frame_appctx(appctx, &skip_receiving);
1689 switch (ret) {
1690 case -1: /* error */
1691 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001692
Christopher Faulet8f82b202018-01-24 16:23:03 +01001693 case 0: /* ignore */
1694 active_r = 1;
1695 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001696
Christopher Faulet8f82b202018-01-24 16:23:03 +01001697 case 1: /* retry */
1698 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001699
Christopher Faulet8f82b202018-01-24 16:23:03 +01001700 default:
1701 active_r = 1;
1702 break;
1703 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001704 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001705
Christopher Faulet8f82b202018-01-24 16:23:03 +01001706 /* send_frame loop */
1707 while (!skip_sending && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
1708 ret = spoe_handle_sending_frame_appctx(appctx, &skip_sending);
1709 switch (ret) {
1710 case -1: /* error */
1711 goto next;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001712
Christopher Faulet8f82b202018-01-24 16:23:03 +01001713 case 0: /* ignore */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001714 if (SPOE_APPCTX(appctx)->node.key)
1715 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001716 active_s++;
1717 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001718
Christopher Faulet8f82b202018-01-24 16:23:03 +01001719 case 1: /* retry */
1720 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001721
Christopher Faulet8f82b202018-01-24 16:23:03 +01001722 default:
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001723 if (SPOE_APPCTX(appctx)->node.key)
1724 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001725 active_s++;
1726 break;
1727 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001728 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001729
Christopher Faulet8f82b202018-01-24 16:23:03 +01001730 if (active_s || active_r) {
Christopher Faulet8f82b202018-01-24 16:23:03 +01001731 update_freq_ctr(&agent->rt[tid].processing_per_sec, active_s);
1732 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1733 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001734
Christopher Faulet8f82b202018-01-24 16:23:03 +01001735 if (appctx->st0 == SPOE_APPCTX_ST_PROCESSING && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
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 Tarreaubafbe012017-11-24 17:34:44 +01001968 appctx->ctx.spoe.ptr = pool_alloc_dirty(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;
Willy Tarreaubafbe012017-11-24 17:34:44 +01001971 memset(appctx->ctx.spoe.ptr, 0, pool_head_spoe_appctx->size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001972
Christopher Faulet42bfa462017-01-04 14:14:19 +01001973 appctx->st0 = SPOE_APPCTX_ST_CONNECT;
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01001974 if ((SPOE_APPCTX(appctx)->task = task_new(tid_bit)) == NULL)
Christopher Faulet42bfa462017-01-04 14:14:19 +01001975 goto out_free_spoe_appctx;
1976
1977 SPOE_APPCTX(appctx)->owner = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001978 SPOE_APPCTX(appctx)->task->process = spoe_process_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001979 SPOE_APPCTX(appctx)->task->context = appctx;
1980 SPOE_APPCTX(appctx)->agent = conf->agent;
1981 SPOE_APPCTX(appctx)->version = 0;
1982 SPOE_APPCTX(appctx)->max_frame_size = conf->agent->max_frame_size;
1983 SPOE_APPCTX(appctx)->flags = 0;
Christopher Fauletb067b062017-01-04 16:39:11 +01001984 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001985 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001986 SPOE_APPCTX(appctx)->cur_fpa = 0;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001987
1988 LIST_INIT(&SPOE_APPCTX(appctx)->buffer_wait.list);
1989 SPOE_APPCTX(appctx)->buffer_wait.target = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001990 SPOE_APPCTX(appctx)->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001991
1992 LIST_INIT(&SPOE_APPCTX(appctx)->list);
1993 LIST_INIT(&SPOE_APPCTX(appctx)->waiting_queue);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001994
Willy Tarreau5820a362016-12-22 15:59:02 +01001995 sess = session_new(&conf->agent_fe, NULL, &appctx->obj_type);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001996 if (!sess)
1997 goto out_free_spoe;
1998
Willy Tarreau87787ac2017-08-28 16:22:54 +02001999 if ((strm = stream_new(sess, &appctx->obj_type)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002000 goto out_free_sess;
2001
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002002 stream_set_backend(strm, conf->agent->b.be);
2003
2004 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002005 si_cant_get(&strm->si[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002006 appctx_wakeup(appctx);
2007
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002008 strm->do_log = NULL;
2009 strm->res.flags |= CF_READ_DONTWAIT;
2010
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002011 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02002012 LIST_ADDQ(&conf->agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002013 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002014 _HA_ATOMIC_ADD(&conf->agent->counters.applets, 1);
Emeric Brun5f77fef2017-05-29 15:26:51 +02002015
Emeric Brunc60def82017-09-27 14:59:38 +02002016 task_wakeup(SPOE_APPCTX(appctx)->task, TASK_WOKEN_INIT);
Willy Tarreau87787ac2017-08-28 16:22:54 +02002017 task_wakeup(strm->task, TASK_WOKEN_INIT);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002018 return appctx;
2019
2020 /* Error unrolling */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002021 out_free_sess:
2022 session_free(sess);
2023 out_free_spoe:
Olivier Houchard3f795f72019-04-17 22:51:06 +02002024 task_destroy(SPOE_APPCTX(appctx)->task);
Christopher Faulet42bfa462017-01-04 14:14:19 +01002025 out_free_spoe_appctx:
Willy Tarreaubafbe012017-11-24 17:34:44 +01002026 pool_free(pool_head_spoe_appctx, SPOE_APPCTX(appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002027 out_free_appctx:
2028 appctx_free(appctx);
2029 out_error:
2030 return NULL;
2031}
2032
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002033static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002034spoe_queue_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002035{
2036 struct spoe_config *conf = FLT_CONF(ctx->filter);
2037 struct spoe_agent *agent = conf->agent;
2038 struct appctx *appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002039 struct spoe_appctx *spoe_appctx;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002040
Christopher Fauleta1cda022016-12-21 08:58:06 +01002041 /* Check if we need to create a new SPOE applet or not. */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002042 if (!eb_is_empty(&agent->rt[tid].idle_applets) &&
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002043 agent->rt[tid].processing < read_freq_ctr(&agent->rt[tid].processing_per_sec))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002044 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002045
2046 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauleta1cda022016-12-21 08:58:06 +01002047 " - try to create new SPOE appctx\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002048 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
2049 ctx->strm);
2050
Christopher Fauleta1cda022016-12-21 08:58:06 +01002051 /* Do not try to create a new applet if there is no server up for the
2052 * agent's backend. */
2053 if (!agent->b.be->srv_act && !agent->b.be->srv_bck) {
2054 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2055 " - cannot create SPOE appctx: no server up\n",
2056 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2057 __FUNCTION__, ctx->strm);
2058 goto end;
2059 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002060
Christopher Fauleta1cda022016-12-21 08:58:06 +01002061 /* Do not try to create a new applet if we have reached the maximum of
2062 * connection per seconds */
Christopher Faulet48026722016-11-16 15:01:12 +01002063 if (agent->cps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002064 if (!freq_ctr_remain(&agent->rt[tid].conn_per_sec, agent->cps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002065 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2066 " - cannot create SPOE appctx: max CPS reached\n",
2067 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2068 __FUNCTION__, ctx->strm);
2069 goto end;
2070 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002071 }
2072
Christopher Faulet8ef75252017-02-20 22:56:03 +01002073 appctx = spoe_create_appctx(conf);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002074 if (appctx == NULL) {
2075 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2076 " - failed to create SPOE appctx\n",
2077 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2078 __FUNCTION__, ctx->strm);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02002079 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01002080 "SPOE: [%s] failed to create SPOE applet\n",
2081 agent->id);
2082
Christopher Fauleta1cda022016-12-21 08:58:06 +01002083 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002084 }
2085
Christopher Fauleta1cda022016-12-21 08:58:06 +01002086 /* Increase the per-process number of cumulated connections */
2087 if (agent->cps_max > 0)
Christopher Faulet24289f22017-09-25 14:48:02 +02002088 update_freq_ctr(&agent->rt[tid].conn_per_sec, 1);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002089
Christopher Fauleta1cda022016-12-21 08:58:06 +01002090 end:
2091 /* The only reason to return an error is when there is no applet */
Christopher Faulet24289f22017-09-25 14:48:02 +02002092 if (LIST_ISEMPTY(&agent->rt[tid].applets)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002093 ctx->status_code = SPOE_CTX_ERR_RES;
2094 return -1;
2095 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002096
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002097 /* Add the SPOE context in the sending queue if the stream has no applet
2098 * already assigned and wakeup all idle applets. Otherwise, don't queue
2099 * it. */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002100 _HA_ATOMIC_ADD(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002101 spoe_update_stat_time(&ctx->stats.tv_request, &ctx->stats.t_request);
2102 ctx->stats.tv_queue = now;
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002103 if (ctx->spoe_appctx)
2104 return 1;
2105 LIST_ADDQ(&agent->rt[tid].sending_queue, &ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002106
2107 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002108 " - Add stream in sending queue"
Christopher Faulet68db0232018-04-06 11:34:12 +02002109 " - applets=%u - idles=%u - processing=%u\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002110 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
Christopher Faulet68db0232018-04-06 11:34:12 +02002111 ctx->strm, agent->counters.applets, agent->counters.idles,
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002112 agent->rt[tid].processing);
Christopher Fauletf7a30922016-11-10 15:04:51 +01002113
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002114 /* Finally try to wakeup an IDLE applet. */
2115 if (!eb_is_empty(&agent->rt[tid].idle_applets)) {
2116 struct eb32_node *node;
2117
2118 node = eb32_first(&agent->rt[tid].idle_applets);
2119 spoe_appctx = eb32_entry(node, struct spoe_appctx, node);
2120 if (node && spoe_appctx) {
2121 eb32_delete(&spoe_appctx->node);
2122 spoe_appctx->node.key++;
2123 eb32_insert(&agent->rt[tid].idle_applets, &spoe_appctx->node);
2124 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002125 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002126 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002127 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002128}
2129
2130/***************************************************************************
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002131 * Functions that encode SPOE messages
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002132 **************************************************************************/
Christopher Faulet10e37672017-09-21 16:38:22 +02002133/* Encode a SPOE message. Info in <ctx->frag_ctx>, if any, are used to handle
2134 * fragmented_content. If the next message can be processed, it returns 0. If
2135 * the message is too big, it returns -1.*/
2136static int
2137spoe_encode_message(struct stream *s, struct spoe_context *ctx,
2138 struct spoe_message *msg, int dir,
2139 char **buf, char *end)
2140{
2141 struct sample *smp;
2142 struct spoe_arg *arg;
2143 int ret;
2144
2145 if (msg->cond) {
2146 ret = acl_exec_cond(msg->cond, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2147 ret = acl_pass(ret);
2148 if (msg->cond->pol == ACL_COND_UNLESS)
2149 ret = !ret;
2150
2151 /* the rule does not match */
2152 if (!ret)
2153 goto next;
2154 }
2155
2156 /* Resume encoding of a SPOE argument */
2157 if (ctx->frag_ctx.curarg != NULL) {
2158 arg = ctx->frag_ctx.curarg;
2159 goto encode_argument;
2160 }
2161
2162 if (ctx->frag_ctx.curoff != UINT_MAX)
2163 goto encode_msg_payload;
2164
2165 /* Check if there is enough space for the message name and the
2166 * number of arguments. It implies <msg->id_len> is encoded on 2
2167 * bytes, at most (< 2288). */
2168 if (*buf + 2 + msg->id_len + 1 > end)
2169 goto too_big;
2170
2171 /* Encode the message name */
2172 if (spoe_encode_buffer(msg->id, msg->id_len, buf, end) == -1)
2173 goto too_big;
2174
2175 /* Set the number of arguments for this message */
2176 **buf = msg->nargs;
2177 (*buf)++;
2178
2179 ctx->frag_ctx.curoff = 0;
2180 encode_msg_payload:
2181
2182 /* Loop on arguments */
2183 list_for_each_entry(arg, &msg->args, list) {
2184 ctx->frag_ctx.curarg = arg;
2185 ctx->frag_ctx.curoff = UINT_MAX;
Kevin Zhuf7f54282019-04-26 14:00:01 +08002186 ctx->frag_ctx.curlen = 0;
Christopher Faulet10e37672017-09-21 16:38:22 +02002187
2188 encode_argument:
2189 if (ctx->frag_ctx.curoff != UINT_MAX)
2190 goto encode_arg_value;
2191
Joseph Herlantf7f60312018-11-15 13:46:49 -08002192 /* Encode the argument name as a string. It can by NULL */
Christopher Faulet10e37672017-09-21 16:38:22 +02002193 if (spoe_encode_buffer(arg->name, arg->name_len, buf, end) == -1)
2194 goto too_big;
2195
2196 ctx->frag_ctx.curoff = 0;
2197 encode_arg_value:
2198
Joseph Herlantf7f60312018-11-15 13:46:49 -08002199 /* Fetch the argument value */
Christopher Faulet10e37672017-09-21 16:38:22 +02002200 smp = sample_process(s->be, s->sess, s, dir|SMP_OPT_FINAL, arg->expr, NULL);
Christopher Faulet3b1d0042019-05-06 09:53:10 +02002201 if (smp) {
2202 smp->ctx.a[0] = &ctx->frag_ctx.curlen;
2203 smp->ctx.a[1] = &ctx->frag_ctx.curoff;
2204 }
Christopher Faulet85db3212019-04-26 14:30:15 +02002205 ret = spoe_encode_data(smp, buf, end);
Christopher Faulet10e37672017-09-21 16:38:22 +02002206 if (ret == -1 || ctx->frag_ctx.curoff)
2207 goto too_big;
2208 }
2209
2210 next:
2211 return 0;
2212
2213 too_big:
2214 return -1;
2215}
2216
Christopher Fauletc718b822017-09-21 16:50:56 +02002217/* Encode list of SPOE messages. Info in <ctx->frag_ctx>, if any, are used to
2218 * handle fragmented content. On success it returns 1. If an error occurred, -1
2219 * is returned. If nothing has been encoded, it returns 0 (this is only possible
2220 * for unfragmented payload). */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002221static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002222spoe_encode_messages(struct stream *s, struct spoe_context *ctx,
Christopher Fauletc718b822017-09-21 16:50:56 +02002223 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002224{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002225 struct spoe_config *conf = FLT_CONF(ctx->filter);
2226 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002227 struct spoe_message *msg;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002228 char *p, *end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002229
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002230 p = b_head(&ctx->buffer);
Christopher Faulet24289f22017-09-25 14:48:02 +02002231 end = p + agent->rt[tid].frame_size - FRAME_HDR_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002232
Christopher Fauletc718b822017-09-21 16:50:56 +02002233 if (type == SPOE_MSGS_BY_EVENT) { /* Loop on messages by event */
2234 /* Resume encoding of a SPOE message */
2235 if (ctx->frag_ctx.curmsg != NULL) {
2236 msg = ctx->frag_ctx.curmsg;
2237 goto encode_evt_message;
2238 }
2239
2240 list_for_each_entry(msg, messages, by_evt) {
2241 ctx->frag_ctx.curmsg = msg;
2242 ctx->frag_ctx.curarg = NULL;
2243 ctx->frag_ctx.curoff = UINT_MAX;
2244
2245 encode_evt_message:
2246 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2247 goto too_big;
2248 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002249 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002250 else if (type == SPOE_MSGS_BY_GROUP) { /* Loop on messages by group */
2251 /* Resume encoding of a SPOE message */
2252 if (ctx->frag_ctx.curmsg != NULL) {
2253 msg = ctx->frag_ctx.curmsg;
2254 goto encode_grp_message;
2255 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002256
Christopher Fauletc718b822017-09-21 16:50:56 +02002257 list_for_each_entry(msg, messages, by_grp) {
2258 ctx->frag_ctx.curmsg = msg;
2259 ctx->frag_ctx.curarg = NULL;
2260 ctx->frag_ctx.curoff = UINT_MAX;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002261
Christopher Fauletc718b822017-09-21 16:50:56 +02002262 encode_grp_message:
2263 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2264 goto too_big;
2265 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002266 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002267 else
2268 goto skip;
2269
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002270
Christopher Faulet57583e42017-09-04 15:41:09 +02002271 /* nothing has been encoded for an unfragmented payload */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002272 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) && p == b_head(&ctx->buffer))
Christopher Faulet57583e42017-09-04 15:41:09 +02002273 goto skip;
2274
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002275 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002276 " - encode %s messages - spoe_appctx=%p"
2277 "- max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002278 (int)now.tv_sec, (int)now.tv_usec,
2279 agent->id, __FUNCTION__, s,
2280 ((ctx->flags & SPOE_CTX_FL_FRAGMENTED) ? "last fragment of" : "unfragmented"),
Christopher Fauletfce747b2018-01-24 15:59:32 +01002281 ctx->spoe_appctx, (agent->rt[tid].frame_size - FRAME_HDR_SIZE),
Christopher Faulet45073512018-07-20 10:16:29 +02002282 p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002283
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002284 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002285 ctx->frag_ctx.curmsg = NULL;
2286 ctx->frag_ctx.curarg = NULL;
2287 ctx->frag_ctx.curoff = 0;
2288 ctx->frag_ctx.flags = SPOE_FRM_FL_FIN;
Christopher Faulet57583e42017-09-04 15:41:09 +02002289
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002290 return 1;
2291
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002292 too_big:
Christopher Fauleta715ea82019-04-10 14:21:51 +02002293 /* Return an error if fragmentation is unsupported or if nothing has
2294 * been encoded because its too big and not splittable. */
2295 if (!(agent->flags & SPOE_FL_SND_FRAGMENTATION) || p == b_head(&ctx->buffer)) {
Christopher Fauletcecd8522017-02-24 22:11:21 +01002296 ctx->status_code = SPOE_CTX_ERR_TOO_BIG;
2297 return -1;
2298 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002299
2300 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002301 " - encode fragmented messages - spoe_appctx=%p"
2302 " - curmsg=%p - curarg=%p - curoff=%u"
2303 " - max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002304 (int)now.tv_sec, (int)now.tv_usec,
Christopher Fauletfce747b2018-01-24 15:59:32 +01002305 agent->id, __FUNCTION__, s, ctx->spoe_appctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002306 ctx->frag_ctx.curmsg, ctx->frag_ctx.curarg, ctx->frag_ctx.curoff,
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002307 (agent->rt[tid].frame_size - FRAME_HDR_SIZE), p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002308
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002309 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002310 ctx->flags |= SPOE_CTX_FL_FRAGMENTED;
2311 ctx->frag_ctx.flags &= ~SPOE_FRM_FL_FIN;
2312 return 1;
Christopher Faulet57583e42017-09-04 15:41:09 +02002313
2314 skip:
2315 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2316 " - skip the frame because nothing has been encoded\n",
2317 (int)now.tv_sec, (int)now.tv_usec,
2318 agent->id, __FUNCTION__, s);
2319 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002320}
2321
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002322
2323/***************************************************************************
2324 * Functions that handle SPOE actions
2325 **************************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002326/* Helper function to set a variable */
2327static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002328spoe_set_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002329 struct sample *smp)
2330{
2331 struct spoe_config *conf = FLT_CONF(ctx->filter);
2332 struct spoe_agent *agent = conf->agent;
2333 char varname[64];
2334
2335 memset(varname, 0, sizeof(varname));
2336 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2337 scope, agent->var_pfx, len, name);
Etienne Carriereaec89892017-12-14 09:36:40 +00002338 if (agent->flags & SPOE_FL_FORCE_SET_VAR)
2339 vars_set_by_name(varname, len, smp);
2340 else
2341 vars_set_by_name_ifexist(varname, len, smp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002342}
2343
2344/* Helper function to unset a variable */
2345static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002346spoe_unset_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002347 struct sample *smp)
2348{
2349 struct spoe_config *conf = FLT_CONF(ctx->filter);
2350 struct spoe_agent *agent = conf->agent;
2351 char varname[64];
2352
2353 memset(varname, 0, sizeof(varname));
2354 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2355 scope, agent->var_pfx, len, name);
2356 vars_unset_by_name_ifexist(varname, len, smp);
2357}
2358
2359
Christopher Faulet8ef75252017-02-20 22:56:03 +01002360static inline int
2361spoe_decode_action_set_var(struct stream *s, struct spoe_context *ctx,
2362 char **buf, char *end, int dir)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002363{
Christopher Faulet8ef75252017-02-20 22:56:03 +01002364 char *str, *scope, *p = *buf;
2365 struct sample smp;
2366 uint64_t sz;
2367 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002368
Christopher Faulet8ef75252017-02-20 22:56:03 +01002369 if (p + 2 >= end)
2370 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002371
Christopher Faulet8ef75252017-02-20 22:56:03 +01002372 /* SET-VAR requires 3 arguments */
2373 if (*p++ != 3)
2374 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002375
Christopher Faulet8ef75252017-02-20 22:56:03 +01002376 switch (*p++) {
2377 case SPOE_SCOPE_PROC: scope = "proc"; break;
2378 case SPOE_SCOPE_SESS: scope = "sess"; break;
2379 case SPOE_SCOPE_TXN : scope = "txn"; break;
2380 case SPOE_SCOPE_REQ : scope = "req"; break;
2381 case SPOE_SCOPE_RES : scope = "res"; break;
2382 default: goto skip;
2383 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002384
Christopher Faulet8ef75252017-02-20 22:56:03 +01002385 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2386 goto skip;
2387 memset(&smp, 0, sizeof(smp));
2388 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002389
Christopher Faulet8ef75252017-02-20 22:56:03 +01002390 if (spoe_decode_data(&p, end, &smp) == -1)
2391 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002392
Christopher Faulet8ef75252017-02-20 22:56:03 +01002393 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2394 " - set-var '%s.%s.%.*s'\n",
2395 (int)now.tv_sec, (int)now.tv_usec,
2396 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2397 __FUNCTION__, s, scope,
2398 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2399 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002400
Christopher Faulet8ef75252017-02-20 22:56:03 +01002401 spoe_set_var(ctx, scope, str, sz, &smp);
Christopher Fauletb5cff602016-11-24 14:53:22 +01002402
Christopher Faulet8ef75252017-02-20 22:56:03 +01002403 ret = (p - *buf);
2404 *buf = p;
2405 return ret;
2406 skip:
2407 return 0;
2408}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002409
Christopher Faulet8ef75252017-02-20 22:56:03 +01002410static inline int
2411spoe_decode_action_unset_var(struct stream *s, struct spoe_context *ctx,
2412 char **buf, char *end, int dir)
2413{
2414 char *str, *scope, *p = *buf;
2415 struct sample smp;
2416 uint64_t sz;
2417 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002418
Christopher Faulet8ef75252017-02-20 22:56:03 +01002419 if (p + 2 >= end)
2420 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002421
Christopher Faulet8ef75252017-02-20 22:56:03 +01002422 /* UNSET-VAR requires 2 arguments */
2423 if (*p++ != 2)
2424 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002425
Christopher Faulet8ef75252017-02-20 22:56:03 +01002426 switch (*p++) {
2427 case SPOE_SCOPE_PROC: scope = "proc"; break;
2428 case SPOE_SCOPE_SESS: scope = "sess"; break;
2429 case SPOE_SCOPE_TXN : scope = "txn"; break;
2430 case SPOE_SCOPE_REQ : scope = "req"; break;
2431 case SPOE_SCOPE_RES : scope = "res"; break;
2432 default: goto skip;
2433 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002434
Christopher Faulet8ef75252017-02-20 22:56:03 +01002435 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2436 goto skip;
2437 memset(&smp, 0, sizeof(smp));
2438 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002439
Christopher Faulet8ef75252017-02-20 22:56:03 +01002440 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2441 " - unset-var '%s.%s.%.*s'\n",
2442 (int)now.tv_sec, (int)now.tv_usec,
2443 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2444 __FUNCTION__, s, scope,
2445 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2446 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002447
Christopher Faulet8ef75252017-02-20 22:56:03 +01002448 spoe_unset_var(ctx, scope, str, sz, &smp);
2449
2450 ret = (p - *buf);
2451 *buf = p;
2452 return ret;
2453 skip:
2454 return 0;
2455}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002456
Christopher Faulet8ef75252017-02-20 22:56:03 +01002457/* Process SPOE actions for a specific event. It returns 1 on success. If an
2458 * error occurred, 0 is returned. */
2459static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002460spoe_process_actions(struct stream *s, struct spoe_context *ctx, int dir)
Christopher Faulet8ef75252017-02-20 22:56:03 +01002461{
2462 char *p, *end;
2463 int ret;
2464
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002465 p = b_head(&ctx->buffer);
2466 end = p + b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002467
2468 while (p < end) {
2469 enum spoe_action_type type;
2470
2471 type = *p++;
2472 switch (type) {
2473 case SPOE_ACT_T_SET_VAR:
2474 ret = spoe_decode_action_set_var(s, ctx, &p, end, dir);
2475 if (!ret)
2476 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002477 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002478
Christopher Faulet8ef75252017-02-20 22:56:03 +01002479 case SPOE_ACT_T_UNSET_VAR:
2480 ret = spoe_decode_action_unset_var(s, ctx, &p, end, dir);
2481 if (!ret)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002482 goto skip;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002483 break;
2484
2485 default:
2486 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002487 }
2488 }
2489
2490 return 1;
2491 skip:
2492 return 0;
2493}
2494
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002495/***************************************************************************
2496 * Functions that process SPOE events
2497 **************************************************************************/
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002498static void
2499spoe_update_stats(struct stream *s, struct spoe_agent *agent,
2500 struct spoe_context *ctx, int dir)
2501{
2502 if (!tv_iszero(&ctx->stats.tv_start)) {
2503 spoe_update_stat_time(&ctx->stats.tv_start, &ctx->stats.t_process);
2504 ctx->stats.t_total += ctx->stats.t_process;
2505 tv_zero(&ctx->stats.tv_request);
2506 tv_zero(&ctx->stats.tv_queue);
2507 tv_zero(&ctx->stats.tv_wait);
2508 tv_zero(&ctx->stats.tv_response);
2509 }
2510
2511 if (agent->var_t_process) {
2512 struct sample smp;
2513
2514 memset(&smp, 0, sizeof(smp));
2515 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2516 smp.data.u.sint = ctx->stats.t_process;
2517 smp.data.type = SMP_T_SINT;
2518
2519 spoe_set_var(ctx, "txn", agent->var_t_process,
2520 strlen(agent->var_t_process), &smp);
2521 }
2522
2523 if (agent->var_t_total) {
2524 struct sample smp;
2525
2526 memset(&smp, 0, sizeof(smp));
2527 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2528 smp.data.u.sint = ctx->stats.t_total;
2529 smp.data.type = SMP_T_SINT;
2530
2531 spoe_set_var(ctx, "txn", agent->var_t_total,
2532 strlen(agent->var_t_total), &smp);
2533 }
2534}
2535
2536static void
2537spoe_handle_processing_error(struct stream *s, struct spoe_agent *agent,
2538 struct spoe_context *ctx, int dir)
2539{
2540 if (agent->eps_max > 0)
2541 update_freq_ctr(&agent->rt[tid].err_per_sec, 1);
2542
2543 if (agent->var_on_error) {
2544 struct sample smp;
2545
2546 memset(&smp, 0, sizeof(smp));
2547 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2548 smp.data.u.sint = ctx->status_code;
2549 smp.data.type = SMP_T_BOOL;
2550
2551 spoe_set_var(ctx, "txn", agent->var_on_error,
2552 strlen(agent->var_on_error), &smp);
2553 }
2554
2555 ctx->state = ((agent->flags & SPOE_FL_CONT_ON_ERR)
2556 ? SPOE_CTX_ST_READY
2557 : SPOE_CTX_ST_NONE);
2558}
2559
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002560static inline int
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002561spoe_start_processing(struct spoe_agent *agent, struct spoe_context *ctx, int dir)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002562{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002563 /* If a process is already started for this SPOE context, retry
2564 * later. */
2565 if (ctx->flags & SPOE_CTX_FL_PROCESS)
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002566 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002567
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002568 agent->rt[tid].processing++;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002569 ctx->stats.tv_start = now;
2570 ctx->stats.tv_request = now;
2571 ctx->stats.t_request = -1;
2572 ctx->stats.t_queue = -1;
2573 ctx->stats.t_waiting = -1;
2574 ctx->stats.t_response = -1;
2575 ctx->stats.t_process = -1;
2576
2577 ctx->status_code = 0;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002578
Christopher Fauleta1cda022016-12-21 08:58:06 +01002579 /* Set the right flag to prevent request and response processing
2580 * in same time. */
2581 ctx->flags |= ((dir == SMP_OPT_DIR_REQ)
2582 ? SPOE_CTX_FL_REQ_PROCESS
2583 : SPOE_CTX_FL_RSP_PROCESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002584 return 1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002585}
2586
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002587static inline void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002588spoe_stop_processing(struct spoe_agent *agent, struct spoe_context *ctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002589{
Christopher Fauletfce747b2018-01-24 15:59:32 +01002590 struct spoe_appctx *sa = ctx->spoe_appctx;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002591
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002592 if (!(ctx->flags & SPOE_CTX_FL_PROCESS))
2593 return;
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002594 _HA_ATOMIC_ADD(&agent->counters.nb_processed, 1);
Christopher Faulet879dca92018-03-23 11:53:24 +01002595 if (sa) {
2596 if (sa->frag_ctx.ctx == ctx) {
2597 sa->frag_ctx.ctx = NULL;
2598 spoe_wakeup_appctx(sa->owner);
2599 }
2600 else
2601 sa->cur_fpa--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002602 }
2603
Christopher Fauleta1cda022016-12-21 08:58:06 +01002604 /* Reset the flag to allow next processing */
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002605 agent->rt[tid].processing--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002606 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002607
2608 /* Reset processing timer */
2609 ctx->process_exp = TICK_ETERNITY;
2610
Christopher Faulet8ef75252017-02-20 22:56:03 +01002611 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002612
Christopher Fauletfce747b2018-01-24 15:59:32 +01002613 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002614 ctx->frag_ctx.curmsg = NULL;
2615 ctx->frag_ctx.curarg = NULL;
2616 ctx->frag_ctx.curoff = 0;
2617 ctx->frag_ctx.flags = 0;
2618
Christopher Fauleta1cda022016-12-21 08:58:06 +01002619 if (!LIST_ISEMPTY(&ctx->list)) {
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002620 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS)
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002621 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002622 else
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002623 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002624
Christopher Fauleta1cda022016-12-21 08:58:06 +01002625 LIST_DEL(&ctx->list);
2626 LIST_INIT(&ctx->list);
2627 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002628}
2629
Christopher Faulet58d03682017-09-21 16:57:24 +02002630/* Process a list of SPOE messages. First, this functions will process messages
2631 * and send them to an agent in a NOTIFY frame. Then, it will wait a ACK frame
2632 * to process corresponding actions. During all the processing, it returns 0
2633 * and it returns 1 when the processing is finished. If an error occurred, -1
2634 * is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002635static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002636spoe_process_messages(struct stream *s, struct spoe_context *ctx,
2637 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002638{
Christopher Fauletf7a30922016-11-10 15:04:51 +01002639 struct spoe_config *conf = FLT_CONF(ctx->filter);
2640 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002641 int ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002642
2643 if (ctx->state == SPOE_CTX_ST_ERROR)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002644 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002645
2646 if (tick_is_expired(ctx->process_exp, now_ms) && ctx->state != SPOE_CTX_ST_DONE) {
2647 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002648 " - failed to process messages: timeout\n",
Christopher Fauletf7a30922016-11-10 15:04:51 +01002649 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002650 agent->id, __FUNCTION__, s);
Christopher Fauletb067b062017-01-04 16:39:11 +01002651 ctx->status_code = SPOE_CTX_ERR_TOUT;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002652 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002653 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002654
2655 if (ctx->state == SPOE_CTX_ST_READY) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002656 if (agent->eps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002657 if (!freq_ctr_remain(&agent->rt[tid].err_per_sec, agent->eps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002658 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002659 " - skip processing of messages: max EPS reached\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002660 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002661 agent->id, __FUNCTION__, s);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002662 goto skip;
2663 }
2664 }
2665
Christopher Fauletf7a30922016-11-10 15:04:51 +01002666 if (!tick_isset(ctx->process_exp)) {
2667 ctx->process_exp = tick_add_ifset(now_ms, agent->timeout.processing);
2668 s->task->expire = tick_first((tick_is_expired(s->task->expire, now_ms) ? 0 : s->task->expire),
2669 ctx->process_exp);
2670 }
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002671 ret = spoe_start_processing(agent, ctx, dir);
Christopher Fauletb067b062017-01-04 16:39:11 +01002672 if (!ret)
2673 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002674
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002675 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002676 /* fall through */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002677 }
2678
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002679 if (ctx->state == SPOE_CTX_ST_ENCODING_MSGS) {
Christopher Faulet63263e52019-04-10 14:47:18 +02002680 if (tv_iszero(&ctx->stats.tv_request))
2681 ctx->stats.tv_request = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002682 if (!spoe_acquire_buffer(&ctx->buffer, &ctx->buffer_wait))
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002683 goto out;
Christopher Faulet58d03682017-09-21 16:57:24 +02002684 ret = spoe_encode_messages(s, ctx, messages, dir, type);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002685 if (ret < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002686 goto end;
Christopher Faulet57583e42017-09-04 15:41:09 +02002687 if (!ret)
2688 goto skip;
Christopher Faulet333694d2018-01-12 10:45:47 +01002689 if (spoe_queue_context(ctx) < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002690 goto end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002691 ctx->state = SPOE_CTX_ST_SENDING_MSGS;
2692 }
2693
2694 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS) {
Christopher Fauletfce747b2018-01-24 15:59:32 +01002695 if (ctx->spoe_appctx)
2696 spoe_wakeup_appctx(ctx->spoe_appctx->owner);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002697 ret = 0;
2698 goto out;
2699 }
2700
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002701 if (ctx->state == SPOE_CTX_ST_WAITING_ACK) {
2702 ret = 0;
2703 goto out;
2704 }
2705
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002706 if (ctx->state == SPOE_CTX_ST_DONE) {
Christopher Faulet58d03682017-09-21 16:57:24 +02002707 spoe_process_actions(s, ctx, dir);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002708 ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002709 ctx->frame_id++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002710 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002711 spoe_update_stat_time(&ctx->stats.tv_response, &ctx->stats.t_response);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002712 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002713 }
2714
2715 out:
2716 return ret;
2717
Christopher Fauleta1cda022016-12-21 08:58:06 +01002718 skip:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002719 tv_zero(&ctx->stats.tv_start);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002720 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002721 spoe_stop_processing(agent, ctx);
2722 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002723
Christopher Fauleta1cda022016-12-21 08:58:06 +01002724 end:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002725 spoe_update_stats(s, agent, ctx, dir);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002726 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002727 if (ctx->status_code) {
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002728 _HA_ATOMIC_ADD(&agent->counters.nb_errors, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002729 spoe_handle_processing_error(s, agent, ctx, dir);
2730 ret = 1;
2731 }
Christopher Faulet58d03682017-09-21 16:57:24 +02002732 return ret;
2733}
2734
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002735/* Process a SPOE group, ie the list of messages attached to the group <grp>.
2736 * See spoe_process_message for details. */
2737static int
2738spoe_process_group(struct stream *s, struct spoe_context *ctx,
2739 struct spoe_group *group, int dir)
2740{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002741 struct spoe_config *conf = FLT_CONF(ctx->filter);
2742 struct spoe_agent *agent = conf->agent;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002743 int ret;
2744
2745 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2746 " - ctx-state=%s - Process messages for group=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002747 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002748 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2749 group->id);
2750
2751 if (LIST_ISEMPTY(&group->messages))
2752 return 1;
2753
2754 ret = spoe_process_messages(s, ctx, &group->messages, dir, SPOE_MSGS_BY_GROUP);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002755 if (ret && ctx->stats.t_process != -1) {
2756 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002757 " - <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 +01002758 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002759 __FUNCTION__, s, group->id, s->uniq_id, ctx->status_code,
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002760 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002761 ctx->stats.t_response, ctx->stats.t_process,
2762 agent->counters.idles, agent->counters.applets,
2763 agent->counters.nb_sending, agent->counters.nb_waiting,
2764 agent->counters.nb_errors, agent->counters.nb_processed,
2765 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2766 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2767 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2768 "SPOE: [%s] <GROUP:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2769 agent->id, group->id, s->uniq_id, ctx->status_code,
2770 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2771 ctx->stats.t_response, ctx->stats.t_process,
2772 agent->counters.idles, agent->counters.applets,
2773 agent->counters.nb_sending, agent->counters.nb_waiting,
2774 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002775 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002776 return ret;
2777}
2778
Christopher Faulet58d03682017-09-21 16:57:24 +02002779/* Process a SPOE event, ie the list of messages attached to the event <ev>.
2780 * See spoe_process_message for details. */
2781static int
2782spoe_process_event(struct stream *s, struct spoe_context *ctx,
2783 enum spoe_event ev)
2784{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002785 struct spoe_config *conf = FLT_CONF(ctx->filter);
2786 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002787 int dir, ret;
2788
2789 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002790 " - ctx-state=%s - Process messages for event=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002791 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet58d03682017-09-21 16:57:24 +02002792 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2793 spoe_event_str[ev]);
2794
2795 dir = ((ev < SPOE_EV_ON_SERVER_SESS) ? SMP_OPT_DIR_REQ : SMP_OPT_DIR_RES);
2796
2797 if (LIST_ISEMPTY(&(ctx->events[ev])))
2798 return 1;
2799
2800 ret = spoe_process_messages(s, ctx, &(ctx->events[ev]), dir, SPOE_MSGS_BY_EVENT);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002801 if (ret && ctx->stats.t_process != -1) {
2802 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002803 " - <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 +01002804 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2805 __FUNCTION__, s, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2806 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002807 ctx->stats.t_response, ctx->stats.t_process,
2808 agent->counters.idles, agent->counters.applets,
2809 agent->counters.nb_sending, agent->counters.nb_waiting,
2810 agent->counters.nb_errors, agent->counters.nb_processed,
2811 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2812 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2813 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2814 "SPOE: [%s] <EVENT:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2815 agent->id, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2816 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2817 ctx->stats.t_response, ctx->stats.t_process,
2818 agent->counters.idles, agent->counters.applets,
2819 agent->counters.nb_sending, agent->counters.nb_waiting,
2820 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002821 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002822 return ret;
2823}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002824
2825/***************************************************************************
2826 * Functions that create/destroy SPOE contexts
2827 **************************************************************************/
Christopher Fauleta1cda022016-12-21 08:58:06 +01002828static int
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002829spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002830{
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002831 if (buf->size)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002832 return 1;
2833
Christopher Faulet4596fb72017-01-11 14:05:19 +01002834 if (!LIST_ISEMPTY(&buffer_wait->list)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002835 HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Faulet4596fb72017-01-11 14:05:19 +01002836 LIST_DEL(&buffer_wait->list);
2837 LIST_INIT(&buffer_wait->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002838 HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002839 }
2840
Christopher Faulet4596fb72017-01-11 14:05:19 +01002841 if (b_alloc_margin(buf, global.tune.reserved_bufs))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002842 return 1;
2843
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002844 HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Faulet4596fb72017-01-11 14:05:19 +01002845 LIST_ADDQ(&buffer_wq, &buffer_wait->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002846 HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002847 return 0;
2848}
2849
2850static void
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002851spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002852{
Christopher Faulet4596fb72017-01-11 14:05:19 +01002853 if (!LIST_ISEMPTY(&buffer_wait->list)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002854 HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Faulet4596fb72017-01-11 14:05:19 +01002855 LIST_DEL(&buffer_wait->list);
2856 LIST_INIT(&buffer_wait->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002857 HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002858 }
2859
2860 /* Release the buffer if needed */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002861 if (buf->size) {
Christopher Faulet4596fb72017-01-11 14:05:19 +01002862 b_free(buf);
Olivier Houchard673867c2018-05-25 16:58:52 +02002863 offer_buffers(buffer_wait->target, tasks_run_queue);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002864 }
2865}
2866
Christopher Faulet4596fb72017-01-11 14:05:19 +01002867static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002868spoe_wakeup_context(struct spoe_context *ctx)
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002869{
2870 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
2871 return 1;
2872}
2873
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002874static struct spoe_context *
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002875spoe_create_context(struct stream *s, struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002876{
2877 struct spoe_config *conf = FLT_CONF(filter);
2878 struct spoe_context *ctx;
2879
Willy Tarreaubafbe012017-11-24 17:34:44 +01002880 ctx = pool_alloc_dirty(pool_head_spoe_ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002881 if (ctx == NULL) {
2882 return NULL;
2883 }
2884 memset(ctx, 0, sizeof(*ctx));
Christopher Fauletb067b062017-01-04 16:39:11 +01002885 ctx->filter = filter;
2886 ctx->state = SPOE_CTX_ST_NONE;
2887 ctx->status_code = SPOE_CTX_ERR_NONE;
2888 ctx->flags = 0;
Christopher Faulet11610f32017-09-21 10:23:10 +02002889 ctx->events = conf->agent->events;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02002890 ctx->groups = &conf->agent->groups;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002891 ctx->buffer = BUF_NULL;
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002892 LIST_INIT(&ctx->buffer_wait.list);
2893 ctx->buffer_wait.target = ctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002894 ctx->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_context;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002895 LIST_INIT(&ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002896
Christopher Fauletf7a30922016-11-10 15:04:51 +01002897 ctx->stream_id = 0;
2898 ctx->frame_id = 1;
2899 ctx->process_exp = TICK_ETERNITY;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002900
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002901 tv_zero(&ctx->stats.tv_start);
2902 tv_zero(&ctx->stats.tv_request);
2903 tv_zero(&ctx->stats.tv_queue);
2904 tv_zero(&ctx->stats.tv_wait);
2905 tv_zero(&ctx->stats.tv_response);
2906 ctx->stats.t_request = -1;
2907 ctx->stats.t_queue = -1;
2908 ctx->stats.t_waiting = -1;
2909 ctx->stats.t_response = -1;
2910 ctx->stats.t_process = -1;
2911 ctx->stats.t_total = 0;
2912
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002913 ctx->strm = s;
2914 ctx->state = SPOE_CTX_ST_READY;
2915 filter->ctx = ctx;
2916
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002917 return ctx;
2918}
2919
2920static void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002921spoe_destroy_context(struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002922{
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002923 struct spoe_config *conf = FLT_CONF(filter);
2924 struct spoe_context *ctx = filter->ctx;
2925
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002926 if (!ctx)
2927 return;
2928
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002929 spoe_stop_processing(conf->agent, ctx);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002930 pool_free(pool_head_spoe_ctx, ctx);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002931 filter->ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002932}
2933
2934static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002935spoe_reset_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002936{
2937 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01002938 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002939
2940 tv_zero(&ctx->stats.tv_start);
2941 tv_zero(&ctx->stats.tv_request);
2942 tv_zero(&ctx->stats.tv_queue);
2943 tv_zero(&ctx->stats.tv_wait);
2944 tv_zero(&ctx->stats.tv_response);
2945 ctx->stats.t_request = -1;
2946 ctx->stats.t_queue = -1;
2947 ctx->stats.t_waiting = -1;
2948 ctx->stats.t_response = -1;
2949 ctx->stats.t_process = -1;
2950 ctx->stats.t_total = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002951}
2952
2953
2954/***************************************************************************
2955 * Hooks that manage the filter lifecycle (init/check/deinit)
2956 **************************************************************************/
2957/* Signal handler: Do a soft stop, wakeup SPOE applet */
2958static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002959spoe_sig_stop(struct sig_handler *sh)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002960{
2961 struct proxy *p;
2962
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002963 p = proxies_list;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002964 while (p) {
2965 struct flt_conf *fconf;
2966
2967 list_for_each_entry(fconf, &p->filter_configs, list) {
Christopher Faulet3b386a32017-02-23 10:17:15 +01002968 struct spoe_config *conf;
2969 struct spoe_agent *agent;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002970 struct spoe_appctx *spoe_appctx;
Christopher Faulet24289f22017-09-25 14:48:02 +02002971 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002972
Christopher Faulet3b386a32017-02-23 10:17:15 +01002973 if (fconf->id != spoe_filter_id)
2974 continue;
2975
2976 conf = fconf->conf;
2977 agent = conf->agent;
2978
Christopher Faulet24289f22017-09-25 14:48:02 +02002979 for (i = 0; i < global.nbthread; ++i) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002980 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02002981 list_for_each_entry(spoe_appctx, &agent->rt[i].applets, list)
2982 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002983 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002984 }
2985 }
2986 p = p->next;
2987 }
2988}
2989
2990
2991/* Initialize the SPOE filter. Returns -1 on error, else 0. */
2992static int
2993spoe_init(struct proxy *px, struct flt_conf *fconf)
2994{
2995 struct spoe_config *conf = fconf->conf;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002996
Christopher Faulet7250b8f2018-03-26 17:19:01 +02002997 /* conf->agent_fe was already initialized during the config
2998 * parsing. Finish initialization. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002999 conf->agent_fe.last_change = now.tv_sec;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003000 conf->agent_fe.cap = PR_CAP_FE;
3001 conf->agent_fe.mode = PR_MODE_TCP;
3002 conf->agent_fe.maxconn = 0;
3003 conf->agent_fe.options2 |= PR_O2_INDEPSTR;
3004 conf->agent_fe.conn_retries = CONN_RETRIES;
3005 conf->agent_fe.accept = frontend_accept;
3006 conf->agent_fe.srv = NULL;
3007 conf->agent_fe.timeout.client = TICK_ETERNITY;
3008 conf->agent_fe.default_target = &spoe_applet.obj_type;
3009 conf->agent_fe.fe_req_ana = AN_REQ_SWITCHING_RULES;
3010
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003011 if (!sighandler_registered) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003012 signal_register_fct(0, spoe_sig_stop, 0);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003013 sighandler_registered = 1;
3014 }
3015
Christopher Faulet00292352019-01-09 15:05:10 +01003016 fconf->flags |= FLT_CFG_FL_HTX;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003017 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003018}
3019
3020/* Free ressources allocated by the SPOE filter. */
3021static void
3022spoe_deinit(struct proxy *px, struct flt_conf *fconf)
3023{
3024 struct spoe_config *conf = fconf->conf;
3025
3026 if (conf) {
3027 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003028
Christopher Faulet8ef75252017-02-20 22:56:03 +01003029 spoe_release_agent(agent);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003030 free(conf->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003031 free(conf);
3032 }
3033 fconf->conf = NULL;
3034}
3035
3036/* Check configuration of a SPOE filter for a specified proxy.
3037 * Return 1 on error, else 0. */
3038static int
3039spoe_check(struct proxy *px, struct flt_conf *fconf)
3040{
Christopher Faulet7ee86672017-09-19 11:08:28 +02003041 struct flt_conf *f;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003042 struct spoe_config *conf = fconf->conf;
3043 struct proxy *target;
Willy Tarreaub0769b22019-02-07 13:40:33 +01003044 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003045
Christopher Faulet7ee86672017-09-19 11:08:28 +02003046 /* Check all SPOE filters for proxy <px> to be sure all SPOE agent names
3047 * are uniq */
3048 list_for_each_entry(f, &px->filter_configs, list) {
3049 struct spoe_config *c = f->conf;
3050
3051 /* This is not an SPOE filter */
3052 if (f->id != spoe_filter_id)
3053 continue;
3054 /* This is the current SPOE filter */
3055 if (f == fconf)
3056 continue;
3057
3058 /* Check engine Id. It should be uniq */
3059 if (!strcmp(conf->id, c->id)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003060 ha_alert("Proxy %s : duplicated name for SPOE engine '%s'.\n",
3061 px->id, conf->id);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003062 return 1;
3063 }
3064 }
3065
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003066 target = proxy_be_by_name(conf->agent->b.name);
3067 if (target == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003068 ha_alert("Proxy %s : unknown backend '%s' used by SPOE agent '%s'"
3069 " declared at %s:%d.\n",
3070 px->id, conf->agent->b.name, conf->agent->id,
3071 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003072 return 1;
3073 }
3074 if (target->mode != PR_MODE_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003075 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3076 " at %s:%d does not support HTTP mode.\n",
3077 px->id, target->id, conf->agent->id,
3078 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003079 return 1;
3080 }
3081
Willy Tarreau2bdcfde2019-02-05 13:37:19 +01003082 if (px->bind_proc & ~target->bind_proc) {
3083 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3084 " at %s:%d does not cover all of its processes.\n",
3085 px->id, target->id, conf->agent->id,
3086 conf->agent->conf.file, conf->agent->conf.line);
3087 return 1;
3088 }
3089
Willy Tarreaub0769b22019-02-07 13:40:33 +01003090 /* finish per-thread agent initialization */
3091 if (global.nbthread == 1)
3092 conf->agent->flags |= SPOE_FL_ASYNC;
3093
Christopher Fauletfe261552019-03-18 13:57:42 +01003094 if ((conf->agent->rt = calloc(global.nbthread, sizeof(*conf->agent->rt))) == NULL) {
Willy Tarreaub0769b22019-02-07 13:40:33 +01003095 ha_alert("Proxy %s : out of memory initializing SPOE agent '%s' declared at %s:%d.\n",
3096 px->id, conf->agent->id, conf->agent->conf.file, conf->agent->conf.line);
3097 return 1;
3098 }
3099 for (i = 0; i < global.nbthread; ++i) {
Christopher Fauletfe261552019-03-18 13:57:42 +01003100 conf->agent->rt[i].frame_size = conf->agent->max_frame_size;
3101 conf->agent->rt[i].processing = 0;
3102 LIST_INIT(&conf->agent->rt[i].applets);
3103 LIST_INIT(&conf->agent->rt[i].sending_queue);
3104 LIST_INIT(&conf->agent->rt[i].waiting_queue);
3105 HA_SPIN_INIT(&conf->agent->rt[i].lock);
Willy Tarreaub0769b22019-02-07 13:40:33 +01003106 }
3107
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003108 free(conf->agent->b.name);
3109 conf->agent->b.name = NULL;
3110 conf->agent->b.be = target;
3111 return 0;
3112}
3113
3114/**************************************************************************
3115 * Hooks attached to a stream
3116 *************************************************************************/
3117/* Called when a filter instance is created and attach to a stream. It creates
3118 * the context that will be used to process this stream. */
3119static int
3120spoe_start(struct stream *s, struct filter *filter)
3121{
Christopher Faulet72bcc472017-01-04 16:39:41 +01003122 struct spoe_config *conf = FLT_CONF(filter);
3123 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003124 struct spoe_context *ctx;
3125
3126 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
Christopher Faulet72bcc472017-01-04 16:39:41 +01003127 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003128 __FUNCTION__, s);
3129
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003130 if ((ctx = spoe_create_context(s, filter)) == NULL) {
Christopher Faulet72bcc472017-01-04 16:39:41 +01003131 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
3132 " - failed to create SPOE context\n",
3133 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletccbc3fd2017-09-15 11:51:18 +02003134 __FUNCTION__, s);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02003135 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01003136 "SPOE: [%s] failed to create SPOE context\n",
3137 agent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003138 return 0;
3139 }
3140
Christopher Faulet11610f32017-09-21 10:23:10 +02003141 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003142 filter->pre_analyzers |= AN_REQ_INSPECT_FE;
3143
Christopher Faulet11610f32017-09-21 10:23:10 +02003144 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003145 filter->pre_analyzers |= AN_REQ_INSPECT_BE;
3146
Christopher Faulet11610f32017-09-21 10:23:10 +02003147 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003148 filter->pre_analyzers |= AN_RES_INSPECT;
3149
Christopher Faulet11610f32017-09-21 10:23:10 +02003150 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003151 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_FE;
3152
Christopher Faulet11610f32017-09-21 10:23:10 +02003153 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003154 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_BE;
3155
Christopher Faulet11610f32017-09-21 10:23:10 +02003156 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003157 filter->pre_analyzers |= AN_RES_HTTP_PROCESS_FE;
3158
3159 return 1;
3160}
3161
3162/* Called when a filter instance is detached from a stream. It release the
3163 * attached SPOE context. */
3164static void
3165spoe_stop(struct stream *s, struct filter *filter)
3166{
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003167 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
3168 (int)now.tv_sec, (int)now.tv_usec,
3169 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3170 __FUNCTION__, s);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003171 spoe_destroy_context(filter);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003172}
3173
Christopher Fauletf7a30922016-11-10 15:04:51 +01003174
3175/*
3176 * Called when the stream is woken up because of expired timer.
3177 */
3178static void
3179spoe_check_timeouts(struct stream *s, struct filter *filter)
3180{
3181 struct spoe_context *ctx = filter->ctx;
3182
Christopher Fauletac580602018-03-20 16:09:20 +01003183 if (tick_is_expired(ctx->process_exp, now_ms))
Christopher Fauleta73e59b2016-12-09 17:30:18 +01003184 s->pending_events |= TASK_WOKEN_MSG;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003185}
3186
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003187/* Called when we are ready to filter data on a channel */
3188static int
3189spoe_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3190{
3191 struct spoe_context *ctx = filter->ctx;
3192 int ret = 1;
3193
3194 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3195 " - ctx-flags=0x%08x\n",
3196 (int)now.tv_sec, (int)now.tv_usec,
3197 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3198 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3199
Christopher Fauletb067b062017-01-04 16:39:11 +01003200 if (ctx->state == SPOE_CTX_ST_NONE)
3201 goto out;
3202
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003203 if (!(chn->flags & CF_ISRESP)) {
3204 if (filter->pre_analyzers & AN_REQ_INSPECT_FE)
3205 chn->analysers |= AN_REQ_INSPECT_FE;
3206 if (filter->pre_analyzers & AN_REQ_INSPECT_BE)
3207 chn->analysers |= AN_REQ_INSPECT_BE;
3208
3209 if (ctx->flags & SPOE_CTX_FL_CLI_CONNECTED)
3210 goto out;
3211
3212 ctx->stream_id = s->uniq_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01003213 ret = spoe_process_event(s, ctx, SPOE_EV_ON_CLIENT_SESS);
Christopher Fauletb067b062017-01-04 16:39:11 +01003214 if (!ret)
3215 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003216 ctx->flags |= SPOE_CTX_FL_CLI_CONNECTED;
3217 }
3218 else {
3219 if (filter->pre_analyzers & SPOE_EV_ON_TCP_RSP)
3220 chn->analysers |= AN_RES_INSPECT;
3221
3222 if (ctx->flags & SPOE_CTX_FL_SRV_CONNECTED)
3223 goto out;
3224
Christopher Faulet8ef75252017-02-20 22:56:03 +01003225 ret = spoe_process_event(s, ctx, SPOE_EV_ON_SERVER_SESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003226 if (!ret) {
3227 channel_dont_read(chn);
3228 channel_dont_close(chn);
Christopher Fauletb067b062017-01-04 16:39:11 +01003229 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003230 }
Christopher Fauletb067b062017-01-04 16:39:11 +01003231 ctx->flags |= SPOE_CTX_FL_SRV_CONNECTED;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003232 }
3233
3234 out:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003235 return ret;
3236}
3237
3238/* Called before a processing happens on a given channel */
3239static int
3240spoe_chn_pre_analyze(struct stream *s, struct filter *filter,
3241 struct channel *chn, unsigned an_bit)
3242{
3243 struct spoe_context *ctx = filter->ctx;
3244 int ret = 1;
3245
3246 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3247 " - ctx-flags=0x%08x - ana=0x%08x\n",
3248 (int)now.tv_sec, (int)now.tv_usec,
3249 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3250 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
3251 ctx->flags, an_bit);
3252
Christopher Fauletb067b062017-01-04 16:39:11 +01003253 if (ctx->state == SPOE_CTX_ST_NONE)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003254 goto out;
3255
3256 switch (an_bit) {
3257 case AN_REQ_INSPECT_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003258 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003259 break;
3260 case AN_REQ_INSPECT_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003261 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003262 break;
3263 case AN_RES_INSPECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003264 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003265 break;
3266 case AN_REQ_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003267 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003268 break;
3269 case AN_REQ_HTTP_PROCESS_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003270 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003271 break;
3272 case AN_RES_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003273 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003274 break;
3275 }
3276
3277 out:
Christopher Faulet9cdca972018-02-01 08:45:45 +01003278 if (!ret && (chn->flags & CF_ISRESP)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003279 channel_dont_read(chn);
3280 channel_dont_close(chn);
3281 }
3282 return ret;
3283}
3284
3285/* Called when the filtering on the channel ends. */
3286static int
3287spoe_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3288{
3289 struct spoe_context *ctx = filter->ctx;
3290
3291 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3292 " - ctx-flags=0x%08x\n",
3293 (int)now.tv_sec, (int)now.tv_usec,
3294 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3295 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3296
3297 if (!(ctx->flags & SPOE_CTX_FL_PROCESS)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003298 spoe_reset_context(ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003299 }
3300
3301 return 1;
3302}
3303
3304/********************************************************************
3305 * Functions that manage the filter initialization
3306 ********************************************************************/
3307struct flt_ops spoe_ops = {
3308 /* Manage SPOE filter, called for each filter declaration */
3309 .init = spoe_init,
3310 .deinit = spoe_deinit,
3311 .check = spoe_check,
3312
3313 /* Handle start/stop of SPOE */
Christopher Fauletf7a30922016-11-10 15:04:51 +01003314 .attach = spoe_start,
3315 .detach = spoe_stop,
3316 .check_timeouts = spoe_check_timeouts,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003317
3318 /* Handle channels activity */
3319 .channel_start_analyze = spoe_start_analyze,
3320 .channel_pre_analyze = spoe_chn_pre_analyze,
3321 .channel_end_analyze = spoe_end_analyze,
3322};
3323
3324
3325static int
3326cfg_parse_spoe_agent(const char *file, int linenum, char **args, int kwm)
3327{
3328 const char *err;
3329 int i, err_code = 0;
3330
3331 if ((cfg_scope == NULL && curengine != NULL) ||
3332 (cfg_scope != NULL && curengine == NULL) ||
Christopher Faulete1405e52017-09-19 10:35:35 +02003333 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003334 goto out;
3335
3336 if (!strcmp(args[0], "spoe-agent")) { /* new spoe-agent section */
3337 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003338 ha_alert("parsing [%s:%d] : missing name for spoe-agent section.\n",
3339 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003340 err_code |= ERR_ALERT | ERR_ABORT;
3341 goto out;
3342 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003343 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3344 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003345 goto out;
3346 }
3347
3348 err = invalid_char(args[1]);
3349 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003350 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3351 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003352 err_code |= ERR_ALERT | ERR_ABORT;
3353 goto out;
3354 }
3355
3356 if (curagent != NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003357 ha_alert("parsing [%s:%d] : another spoe-agent section previously defined.\n",
3358 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003359 err_code |= ERR_ALERT | ERR_ABORT;
3360 goto out;
3361 }
3362 if ((curagent = calloc(1, sizeof(*curagent))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003363 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003364 err_code |= ERR_ALERT | ERR_ABORT;
3365 goto out;
3366 }
3367
3368 curagent->id = strdup(args[1]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003369
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003370 curagent->conf.file = strdup(file);
3371 curagent->conf.line = linenum;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003372
3373 curagent->timeout.hello = TICK_ETERNITY;
3374 curagent->timeout.idle = TICK_ETERNITY;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003375 curagent->timeout.processing = TICK_ETERNITY;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003376
3377 curagent->engine_id = NULL;
3378 curagent->var_pfx = NULL;
3379 curagent->var_on_error = NULL;
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003380 curagent->var_t_process = NULL;
3381 curagent->var_t_total = NULL;
Christopher Faulet24289f22017-09-25 14:48:02 +02003382 curagent->flags = (SPOE_FL_PIPELINING | SPOE_FL_SND_FRAGMENTATION);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003383 curagent->cps_max = 0;
3384 curagent->eps_max = 0;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01003385 curagent->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01003386 curagent->max_fpa = 20;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003387
3388 for (i = 0; i < SPOE_EV_EVENTS; ++i)
Christopher Faulet11610f32017-09-21 10:23:10 +02003389 LIST_INIT(&curagent->events[i]);
3390 LIST_INIT(&curagent->groups);
3391 LIST_INIT(&curagent->messages);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003392 }
3393 else if (!strcmp(args[0], "use-backend")) {
3394 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003395 ha_alert("parsing [%s:%d] : '%s' expects a backend name.\n",
3396 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003397 err_code |= ERR_ALERT | ERR_FATAL;
3398 goto out;
3399 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003400 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003401 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003402 free(curagent->b.name);
3403 curagent->b.name = strdup(args[1]);
3404 }
3405 else if (!strcmp(args[0], "messages")) {
3406 int cur_arg = 1;
3407 while (*args[cur_arg]) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003408 struct spoe_placeholder *ph = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003409
Christopher Faulet11610f32017-09-21 10:23:10 +02003410 list_for_each_entry(ph, &curmphs, list) {
3411 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003412 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3413 file, linenum, args[cur_arg]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003414 err_code |= ERR_ALERT | ERR_FATAL;
3415 goto out;
3416 }
3417 }
3418
Christopher Faulet11610f32017-09-21 10:23:10 +02003419 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003420 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003421 err_code |= ERR_ALERT | ERR_ABORT;
3422 goto out;
3423 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003424 ph->id = strdup(args[cur_arg]);
3425 LIST_ADDQ(&curmphs, &ph->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003426 cur_arg++;
3427 }
3428 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003429 else if (!strcmp(args[0], "groups")) {
3430 int cur_arg = 1;
3431 while (*args[cur_arg]) {
3432 struct spoe_placeholder *ph = NULL;
3433
3434 list_for_each_entry(ph, &curgphs, list) {
3435 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003436 ha_alert("parsing [%s:%d]: spoe-group '%s' already used.\n",
3437 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003438 err_code |= ERR_ALERT | ERR_FATAL;
3439 goto out;
3440 }
3441 }
3442
3443 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003444 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003445 err_code |= ERR_ALERT | ERR_ABORT;
3446 goto out;
3447 }
3448 ph->id = strdup(args[cur_arg]);
3449 LIST_ADDQ(&curgphs, &ph->list);
3450 cur_arg++;
3451 }
3452 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003453 else if (!strcmp(args[0], "timeout")) {
3454 unsigned int *tv = NULL;
3455 const char *res;
3456 unsigned timeout;
3457
3458 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003459 ha_alert("parsing [%s:%d] : 'timeout' expects 'hello', 'idle' and 'processing'.\n",
3460 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003461 err_code |= ERR_ALERT | ERR_FATAL;
3462 goto out;
3463 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003464 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3465 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003466 if (!strcmp(args[1], "hello"))
3467 tv = &curagent->timeout.hello;
3468 else if (!strcmp(args[1], "idle"))
3469 tv = &curagent->timeout.idle;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003470 else if (!strcmp(args[1], "processing"))
3471 tv = &curagent->timeout.processing;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003472 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003473 ha_alert("parsing [%s:%d] : 'timeout' supports 'hello', 'idle' or 'processing' (got %s).\n",
3474 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003475 err_code |= ERR_ALERT | ERR_FATAL;
3476 goto out;
3477 }
3478 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003479 ha_alert("parsing [%s:%d] : 'timeout %s' expects an integer value (in milliseconds).\n",
3480 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003481 err_code |= ERR_ALERT | ERR_FATAL;
3482 goto out;
3483 }
3484 res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02003485 if (res == PARSE_TIME_OVER) {
3486 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
3487 file, linenum, args[2], args[0], args[1]);
3488 err_code |= ERR_ALERT | ERR_FATAL;
3489 goto out;
3490 }
3491 else if (res == PARSE_TIME_UNDER) {
3492 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
3493 file, linenum, args[2], args[0], args[1]);
3494 err_code |= ERR_ALERT | ERR_FATAL;
3495 goto out;
3496 }
3497 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003498 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'timeout %s'.\n",
3499 file, linenum, *res, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003500 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003501 goto out;
3502 }
3503 *tv = MS_TO_TICKS(timeout);
3504 }
3505 else if (!strcmp(args[0], "option")) {
3506 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003507 ha_alert("parsing [%s:%d]: '%s' expects an option name.\n",
3508 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003509 err_code |= ERR_ALERT | ERR_FATAL;
3510 goto out;
3511 }
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003512
Christopher Faulet305c6072017-02-23 16:17:53 +01003513 if (!strcmp(args[1], "pipelining")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003514 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003515 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003516 if (kwm == 1)
3517 curagent->flags &= ~SPOE_FL_PIPELINING;
3518 else
3519 curagent->flags |= SPOE_FL_PIPELINING;
3520 goto out;
3521 }
3522 else if (!strcmp(args[1], "async")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003523 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003524 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003525 if (kwm == 1)
3526 curagent->flags &= ~SPOE_FL_ASYNC;
Christopher Faulet24289f22017-09-25 14:48:02 +02003527 else {
3528 if (global.nbthread == 1)
3529 curagent->flags |= SPOE_FL_ASYNC;
3530 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003531 ha_warning("parsing [%s:%d] Async option is not supported with threads.\n",
3532 file, linenum);
Christopher Faulet24289f22017-09-25 14:48:02 +02003533 err_code |= ERR_WARN;
3534 }
3535 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003536 goto out;
3537 }
Christopher Fauletcecd8522017-02-24 22:11:21 +01003538 else if (!strcmp(args[1], "send-frag-payload")) {
3539 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3540 goto out;
3541 if (kwm == 1)
3542 curagent->flags &= ~SPOE_FL_SND_FRAGMENTATION;
3543 else
3544 curagent->flags |= SPOE_FL_SND_FRAGMENTATION;
3545 goto out;
3546 }
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003547 else if (!strcmp(args[1], "dontlog-normal")) {
3548 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3549 goto out;
3550 if (kwm == 1)
3551 curpxopts2 &= ~PR_O2_NOLOGNORM;
3552 else
3553 curpxopts2 |= PR_O2_NOLOGNORM;
Christopher Faulet799f5182018-04-26 11:36:34 +02003554 goto out;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003555 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003556
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003557 /* Following options does not support negation */
3558 if (kwm == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003559 ha_alert("parsing [%s:%d]: negation is not supported for option '%s'.\n",
3560 file, linenum, args[1]);
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003561 err_code |= ERR_ALERT | ERR_FATAL;
3562 goto out;
3563 }
3564
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003565 if (!strcmp(args[1], "var-prefix")) {
3566 char *tmp;
3567
3568 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003569 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3570 file, linenum, args[0],
3571 args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003572 err_code |= ERR_ALERT | ERR_FATAL;
3573 goto out;
3574 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003575 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3576 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003577 tmp = args[2];
3578 while (*tmp) {
3579 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003580 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003581 file, linenum, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003582 err_code |= ERR_ALERT | ERR_FATAL;
3583 goto out;
3584 }
3585 tmp++;
3586 }
3587 curagent->var_pfx = strdup(args[2]);
3588 }
Etienne Carriereaec89892017-12-14 09:36:40 +00003589 else if (!strcmp(args[1], "force-set-var")) {
3590 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3591 goto out;
3592 curagent->flags |= SPOE_FL_FORCE_SET_VAR;
3593 }
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003594 else if (!strcmp(args[1], "continue-on-error")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003595 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003596 goto out;
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003597 curagent->flags |= SPOE_FL_CONT_ON_ERR;
3598 }
Christopher Faulet985532d2016-11-16 15:36:19 +01003599 else if (!strcmp(args[1], "set-on-error")) {
3600 char *tmp;
3601
3602 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003603 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3604 file, linenum, args[0],
3605 args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003606 err_code |= ERR_ALERT | ERR_FATAL;
3607 goto out;
3608 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003609 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3610 goto out;
Christopher Faulet985532d2016-11-16 15:36:19 +01003611 tmp = args[2];
3612 while (*tmp) {
3613 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003614 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003615 file, linenum, args[0], args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003616 err_code |= ERR_ALERT | ERR_FATAL;
3617 goto out;
3618 }
3619 tmp++;
3620 }
3621 curagent->var_on_error = strdup(args[2]);
3622 }
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003623 else if (!strcmp(args[1], "set-process-time")) {
3624 char *tmp;
3625
3626 if (!*args[2]) {
3627 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3628 file, linenum, args[0],
3629 args[1]);
3630 err_code |= ERR_ALERT | ERR_FATAL;
3631 goto out;
3632 }
3633 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3634 goto out;
3635 tmp = args[2];
3636 while (*tmp) {
3637 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003638 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003639 file, linenum, args[0], args[1]);
3640 err_code |= ERR_ALERT | ERR_FATAL;
3641 goto out;
3642 }
3643 tmp++;
3644 }
3645 curagent->var_t_process = strdup(args[2]);
3646 }
3647 else if (!strcmp(args[1], "set-total-time")) {
3648 char *tmp;
3649
3650 if (!*args[2]) {
3651 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3652 file, linenum, args[0],
3653 args[1]);
3654 err_code |= ERR_ALERT | ERR_FATAL;
3655 goto out;
3656 }
3657 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3658 goto out;
3659 tmp = args[2];
3660 while (*tmp) {
3661 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003662 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003663 file, linenum, args[0], args[1]);
3664 err_code |= ERR_ALERT | ERR_FATAL;
3665 goto out;
3666 }
3667 tmp++;
3668 }
3669 curagent->var_t_total = strdup(args[2]);
3670 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003671 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003672 ha_alert("parsing [%s:%d]: option '%s' is not supported.\n",
3673 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003674 err_code |= ERR_ALERT | ERR_FATAL;
3675 goto out;
3676 }
Christopher Faulet48026722016-11-16 15:01:12 +01003677 }
3678 else if (!strcmp(args[0], "maxconnrate")) {
3679 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003680 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3681 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003682 err_code |= ERR_ALERT | ERR_FATAL;
3683 goto out;
3684 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003685 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003686 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003687 curagent->cps_max = atol(args[1]);
3688 }
3689 else if (!strcmp(args[0], "maxerrrate")) {
3690 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003691 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3692 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003693 err_code |= ERR_ALERT | ERR_FATAL;
3694 goto out;
3695 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003696 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003697 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003698 curagent->eps_max = atol(args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003699 }
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003700 else if (!strcmp(args[0], "max-frame-size")) {
3701 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003702 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3703 file, linenum, args[0]);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003704 err_code |= ERR_ALERT | ERR_FATAL;
3705 goto out;
3706 }
3707 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3708 goto out;
3709 curagent->max_frame_size = atol(args[1]);
3710 if (curagent->max_frame_size < MIN_FRAME_SIZE ||
3711 curagent->max_frame_size > MAX_FRAME_SIZE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003712 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument in the range [%d, %d].\n",
3713 file, linenum, args[0], MIN_FRAME_SIZE, MAX_FRAME_SIZE);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003714 err_code |= ERR_ALERT | ERR_FATAL;
3715 goto out;
3716 }
3717 }
Christopher Faulete8ade382018-01-25 15:32:22 +01003718 else if (!strcmp(args[0], "max-waiting-frames")) {
3719 if (!*args[1]) {
3720 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3721 file, linenum, args[0]);
3722 err_code |= ERR_ALERT | ERR_FATAL;
3723 goto out;
3724 }
3725 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3726 goto out;
3727 curagent->max_fpa = atol(args[1]);
3728 if (curagent->max_fpa < 1) {
3729 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument.\n",
3730 file, linenum, args[0]);
3731 err_code |= ERR_ALERT | ERR_FATAL;
3732 goto out;
3733 }
3734 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003735 else if (!strcmp(args[0], "register-var-names")) {
3736 int cur_arg;
3737
3738 if (!*args[1]) {
3739 ha_alert("parsing [%s:%d] : '%s' expects one or more variable names.\n",
3740 file, linenum, args[0]);
3741 err_code |= ERR_ALERT | ERR_FATAL;
3742 goto out;
3743 }
3744 cur_arg = 1;
3745 while (*args[cur_arg]) {
3746 struct spoe_var_placeholder *vph;
3747
3748 if ((vph = calloc(1, sizeof(*vph))) == NULL) {
3749 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3750 err_code |= ERR_ALERT | ERR_ABORT;
3751 goto out;
3752 }
3753 if ((vph->name = strdup(args[cur_arg])) == NULL) {
3754 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3755 err_code |= ERR_ALERT | ERR_ABORT;
3756 goto out;
3757 }
3758 LIST_ADDQ(&curvars, &vph->list);
3759 cur_arg++;
3760 }
3761 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003762 else if (!strcmp(args[0], "log")) {
3763 char *errmsg = NULL;
3764
3765 if (!parse_logsrv(args, &curlogsrvs, (kwm == 1), &errmsg)) {
3766 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
3767 err_code |= ERR_ALERT | ERR_FATAL;
3768 goto out;
3769 }
3770 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003771 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003772 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-agent section.\n",
3773 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003774 err_code |= ERR_ALERT | ERR_FATAL;
3775 goto out;
3776 }
3777 out:
3778 return err_code;
3779}
Christopher Faulet11610f32017-09-21 10:23:10 +02003780static int
3781cfg_parse_spoe_group(const char *file, int linenum, char **args, int kwm)
3782{
3783 struct spoe_group *grp;
3784 const char *err;
3785 int err_code = 0;
3786
3787 if ((cfg_scope == NULL && curengine != NULL) ||
3788 (cfg_scope != NULL && curengine == NULL) ||
3789 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
3790 goto out;
3791
3792 if (!strcmp(args[0], "spoe-group")) { /* new spoe-group section */
3793 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003794 ha_alert("parsing [%s:%d] : missing name for spoe-group section.\n",
3795 file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003796 err_code |= ERR_ALERT | ERR_ABORT;
3797 goto out;
3798 }
3799 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3800 err_code |= ERR_ABORT;
3801 goto out;
3802 }
3803
3804 err = invalid_char(args[1]);
3805 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003806 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3807 file, linenum, *err, args[0], args[1]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003808 err_code |= ERR_ALERT | ERR_ABORT;
3809 goto out;
3810 }
3811
3812 list_for_each_entry(grp, &curgrps, list) {
3813 if (!strcmp(grp->id, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003814 ha_alert("parsing [%s:%d]: spoe-group section '%s' has the same"
3815 " name as another one declared at %s:%d.\n",
3816 file, linenum, args[1], grp->conf.file, grp->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02003817 err_code |= ERR_ALERT | ERR_FATAL;
3818 goto out;
3819 }
3820 }
3821
3822 if ((curgrp = calloc(1, sizeof(*curgrp))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003823 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003824 err_code |= ERR_ALERT | ERR_ABORT;
3825 goto out;
3826 }
3827
3828 curgrp->id = strdup(args[1]);
3829 curgrp->conf.file = strdup(file);
3830 curgrp->conf.line = linenum;
3831 LIST_INIT(&curgrp->phs);
3832 LIST_INIT(&curgrp->messages);
3833 LIST_ADDQ(&curgrps, &curgrp->list);
3834 }
3835 else if (!strcmp(args[0], "messages")) {
3836 int cur_arg = 1;
3837 while (*args[cur_arg]) {
3838 struct spoe_placeholder *ph = NULL;
3839
3840 list_for_each_entry(ph, &curgrp->phs, list) {
3841 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003842 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3843 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003844 err_code |= ERR_ALERT | ERR_FATAL;
3845 goto out;
3846 }
3847 }
3848
3849 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003850 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003851 err_code |= ERR_ALERT | ERR_ABORT;
3852 goto out;
3853 }
3854 ph->id = strdup(args[cur_arg]);
3855 LIST_ADDQ(&curgrp->phs, &ph->list);
3856 cur_arg++;
3857 }
3858 }
3859 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003860 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-group section.\n",
3861 file, linenum, args[0]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003862 err_code |= ERR_ALERT | ERR_FATAL;
3863 goto out;
3864 }
3865 out:
3866 return err_code;
3867}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003868
3869static int
3870cfg_parse_spoe_message(const char *file, int linenum, char **args, int kwm)
3871{
3872 struct spoe_message *msg;
3873 struct spoe_arg *arg;
3874 const char *err;
3875 char *errmsg = NULL;
3876 int err_code = 0;
3877
3878 if ((cfg_scope == NULL && curengine != NULL) ||
3879 (cfg_scope != NULL && curengine == NULL) ||
Christopher Faulete1405e52017-09-19 10:35:35 +02003880 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003881 goto out;
3882
3883 if (!strcmp(args[0], "spoe-message")) { /* new spoe-message section */
3884 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003885 ha_alert("parsing [%s:%d] : missing name for spoe-message section.\n",
3886 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003887 err_code |= ERR_ALERT | ERR_ABORT;
3888 goto out;
3889 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003890 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3891 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003892 goto out;
3893 }
3894
3895 err = invalid_char(args[1]);
3896 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003897 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3898 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003899 err_code |= ERR_ALERT | ERR_ABORT;
3900 goto out;
3901 }
3902
3903 list_for_each_entry(msg, &curmsgs, list) {
3904 if (!strcmp(msg->id, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003905 ha_alert("parsing [%s:%d]: spoe-message section '%s' has the same"
3906 " name as another one declared at %s:%d.\n",
3907 file, linenum, args[1], msg->conf.file, msg->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003908 err_code |= ERR_ALERT | ERR_FATAL;
3909 goto out;
3910 }
3911 }
3912
3913 if ((curmsg = calloc(1, sizeof(*curmsg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003914 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003915 err_code |= ERR_ALERT | ERR_ABORT;
3916 goto out;
3917 }
3918
3919 curmsg->id = strdup(args[1]);
3920 curmsg->id_len = strlen(curmsg->id);
3921 curmsg->event = SPOE_EV_NONE;
3922 curmsg->conf.file = strdup(file);
3923 curmsg->conf.line = linenum;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003924 curmsg->nargs = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003925 LIST_INIT(&curmsg->args);
Christopher Faulet57583e42017-09-04 15:41:09 +02003926 LIST_INIT(&curmsg->acls);
Christopher Faulet11610f32017-09-21 10:23:10 +02003927 LIST_INIT(&curmsg->by_evt);
3928 LIST_INIT(&curmsg->by_grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003929 LIST_ADDQ(&curmsgs, &curmsg->list);
3930 }
3931 else if (!strcmp(args[0], "args")) {
3932 int cur_arg = 1;
3933
3934 curproxy->conf.args.ctx = ARGC_SPOE;
3935 curproxy->conf.args.file = file;
3936 curproxy->conf.args.line = linenum;
3937 while (*args[cur_arg]) {
3938 char *delim = strchr(args[cur_arg], '=');
3939 int idx = 0;
3940
3941 if ((arg = calloc(1, sizeof(*arg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003942 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003943 err_code |= ERR_ALERT | ERR_ABORT;
3944 goto out;
3945 }
3946
3947 if (!delim) {
3948 arg->name = NULL;
3949 arg->name_len = 0;
3950 delim = args[cur_arg];
3951 }
3952 else {
3953 arg->name = my_strndup(args[cur_arg], delim - args[cur_arg]);
3954 arg->name_len = delim - args[cur_arg];
3955 delim++;
3956 }
Christopher Fauletb0b42382017-02-23 22:41:09 +01003957 arg->expr = sample_parse_expr((char*[]){delim, NULL},
3958 &idx, file, linenum, &errmsg,
3959 &curproxy->conf.args);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003960 if (arg->expr == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003961 ha_alert("parsing [%s:%d] : '%s': %s.\n", file, linenum, args[0], errmsg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003962 err_code |= ERR_ALERT | ERR_FATAL;
3963 free(arg->name);
3964 free(arg);
3965 goto out;
3966 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003967 curmsg->nargs++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003968 LIST_ADDQ(&curmsg->args, &arg->list);
3969 cur_arg++;
3970 }
3971 curproxy->conf.args.file = NULL;
3972 curproxy->conf.args.line = 0;
3973 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003974 else if (!strcmp(args[0], "acl")) {
3975 err = invalid_char(args[1]);
3976 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003977 ha_alert("parsing [%s:%d] : character '%c' is not permitted in acl name '%s'.\n",
3978 file, linenum, *err, args[1]);
Christopher Faulet57583e42017-09-04 15:41:09 +02003979 err_code |= ERR_ALERT | ERR_FATAL;
3980 goto out;
3981 }
3982 if (parse_acl((const char **)args + 1, &curmsg->acls, &errmsg, &curproxy->conf.args, file, linenum) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003983 ha_alert("parsing [%s:%d] : error detected while parsing ACL '%s' : %s.\n",
3984 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02003985 err_code |= ERR_ALERT | ERR_FATAL;
3986 goto out;
3987 }
3988 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003989 else if (!strcmp(args[0], "event")) {
3990 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003991 ha_alert("parsing [%s:%d] : missing event name.\n", file, linenum);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003992 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003993 goto out;
3994 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003995 /* if (alertif_too_many_args(1, file, linenum, args, &err_code)) */
3996 /* goto out; */
Christopher Fauletecc537a2017-02-23 22:52:39 +01003997
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003998 if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_CLIENT_SESS]))
3999 curmsg->event = SPOE_EV_ON_CLIENT_SESS;
4000 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_SERVER_SESS]))
4001 curmsg->event = SPOE_EV_ON_SERVER_SESS;
4002
4003 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_FE]))
4004 curmsg->event = SPOE_EV_ON_TCP_REQ_FE;
4005 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_BE]))
4006 curmsg->event = SPOE_EV_ON_TCP_REQ_BE;
4007 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_RSP]))
4008 curmsg->event = SPOE_EV_ON_TCP_RSP;
4009
4010 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_FE]))
4011 curmsg->event = SPOE_EV_ON_HTTP_REQ_FE;
4012 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_BE]))
4013 curmsg->event = SPOE_EV_ON_HTTP_REQ_BE;
4014 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_RSP]))
4015 curmsg->event = SPOE_EV_ON_HTTP_RSP;
4016 else {
Joseph Herlantf1da69d2018-11-15 13:49:02 -08004017 ha_alert("parsing [%s:%d] : unknown event '%s'.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01004018 file, linenum, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01004019 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004020 goto out;
4021 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004022
4023 if (strcmp(args[2], "if") == 0 || strcmp(args[2], "unless") == 0) {
4024 struct acl_cond *cond;
4025
4026 cond = build_acl_cond(file, linenum, &curmsg->acls,
4027 curproxy, (const char **)args+2,
4028 &errmsg);
4029 if (cond == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004030 ha_alert("parsing [%s:%d] : error detected while "
4031 "parsing an 'event %s' condition : %s.\n",
4032 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02004033 err_code |= ERR_ALERT | ERR_FATAL;
4034 goto out;
4035 }
4036 curmsg->cond = cond;
4037 }
4038 else if (*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004039 ha_alert("parsing [%s:%d]: 'event %s' expects either 'if' "
4040 "or 'unless' followed by a condition but found '%s'.\n",
4041 file, linenum, args[1], args[2]);
Christopher Faulet57583e42017-09-04 15:41:09 +02004042 err_code |= ERR_ALERT | ERR_FATAL;
4043 goto out;
4044 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004045 }
4046 else if (!*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004047 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-message section.\n",
4048 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004049 err_code |= ERR_ALERT | ERR_FATAL;
4050 goto out;
4051 }
4052 out:
4053 free(errmsg);
4054 return err_code;
4055}
4056
4057/* Return -1 on error, else 0 */
4058static int
4059parse_spoe_flt(char **args, int *cur_arg, struct proxy *px,
4060 struct flt_conf *fconf, char **err, void *private)
4061{
4062 struct list backup_sections;
4063 struct spoe_config *conf;
4064 struct spoe_message *msg, *msgback;
Christopher Faulet11610f32017-09-21 10:23:10 +02004065 struct spoe_group *grp, *grpback;
4066 struct spoe_placeholder *ph, *phback;
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004067 struct spoe_var_placeholder *vph, *vphback;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004068 struct logsrv *logsrv, *logsrvback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004069 char *file = NULL, *engine = NULL;
4070 int ret, pos = *cur_arg + 1;
4071
Christopher Faulet84c844e2018-03-23 14:37:14 +01004072 LIST_INIT(&curmsgs);
4073 LIST_INIT(&curgrps);
4074 LIST_INIT(&curmphs);
4075 LIST_INIT(&curgphs);
4076 LIST_INIT(&curvars);
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004077 LIST_INIT(&curlogsrvs);
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004078 curpxopts = 0;
4079 curpxopts2 = 0;
Christopher Faulet84c844e2018-03-23 14:37:14 +01004080
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004081 conf = calloc(1, sizeof(*conf));
4082 if (conf == NULL) {
4083 memprintf(err, "%s: out of memory", args[*cur_arg]);
4084 goto error;
4085 }
4086 conf->proxy = px;
4087
4088 while (*args[pos]) {
4089 if (!strcmp(args[pos], "config")) {
4090 if (!*args[pos+1]) {
4091 memprintf(err, "'%s' : '%s' option without value",
4092 args[*cur_arg], args[pos]);
4093 goto error;
4094 }
4095 file = args[pos+1];
4096 pos += 2;
4097 }
4098 else if (!strcmp(args[pos], "engine")) {
4099 if (!*args[pos+1]) {
4100 memprintf(err, "'%s' : '%s' option without value",
4101 args[*cur_arg], args[pos]);
4102 goto error;
4103 }
4104 engine = args[pos+1];
4105 pos += 2;
4106 }
4107 else {
4108 memprintf(err, "unknown keyword '%s'", args[pos]);
4109 goto error;
4110 }
4111 }
4112 if (file == NULL) {
4113 memprintf(err, "'%s' : missing config file", args[*cur_arg]);
4114 goto error;
4115 }
4116
4117 /* backup sections and register SPOE sections */
4118 LIST_INIT(&backup_sections);
4119 cfg_backup_sections(&backup_sections);
Christopher Faulet11610f32017-09-21 10:23:10 +02004120 cfg_register_section("spoe-agent", cfg_parse_spoe_agent, NULL);
4121 cfg_register_section("spoe-group", cfg_parse_spoe_group, NULL);
William Lallemandd2ff56d2017-10-16 11:06:50 +02004122 cfg_register_section("spoe-message", cfg_parse_spoe_message, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004123
4124 /* Parse SPOE filter configuration file */
4125 curengine = engine;
4126 curproxy = px;
4127 curagent = NULL;
4128 curmsg = NULL;
4129 ret = readcfgfile(file);
4130 curproxy = NULL;
4131
4132 /* unregister SPOE sections and restore previous sections */
4133 cfg_unregister_sections();
4134 cfg_restore_sections(&backup_sections);
4135
4136 if (ret == -1) {
4137 memprintf(err, "Could not open configuration file %s : %s",
4138 file, strerror(errno));
4139 goto error;
4140 }
4141 if (ret & (ERR_ABORT|ERR_FATAL)) {
4142 memprintf(err, "Error(s) found in configuration file %s", file);
4143 goto error;
4144 }
4145
4146 /* Check SPOE agent */
4147 if (curagent == NULL) {
4148 memprintf(err, "No SPOE agent found in file %s", file);
4149 goto error;
4150 }
4151 if (curagent->b.name == NULL) {
4152 memprintf(err, "No backend declared for SPOE agent '%s' declared at %s:%d",
4153 curagent->id, curagent->conf.file, curagent->conf.line);
4154 goto error;
4155 }
Christopher Fauletf7a30922016-11-10 15:04:51 +01004156 if (curagent->timeout.hello == TICK_ETERNITY ||
4157 curagent->timeout.idle == TICK_ETERNITY ||
Christopher Fauletf7a30922016-11-10 15:04:51 +01004158 curagent->timeout.processing == TICK_ETERNITY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004159 ha_warning("Proxy '%s': missing timeouts for SPOE agent '%s' declare at %s:%d.\n"
4160 " | While not properly invalid, you will certainly encounter various problems\n"
4161 " | with such a configuration. To fix this, please ensure that all following\n"
4162 " | timeouts are set to a non-zero value: 'hello', 'idle', 'processing'.\n",
4163 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004164 }
4165 if (curagent->var_pfx == NULL) {
4166 char *tmp = curagent->id;
4167
4168 while (*tmp) {
4169 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
4170 memprintf(err, "Invalid variable prefix '%s' for SPOE agent '%s' declared at %s:%d. "
4171 "Use 'option var-prefix' to set it. Only [a-zA-Z0-9_.] chars are supported.\n",
4172 curagent->id, curagent->id, curagent->conf.file, curagent->conf.line);
4173 goto error;
4174 }
4175 tmp++;
4176 }
4177 curagent->var_pfx = strdup(curagent->id);
4178 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01004179 if (curagent->engine_id == NULL)
4180 curagent->engine_id = generate_pseudo_uuid();
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004181
Christopher Fauletb7426d12018-03-21 14:12:17 +01004182 if (curagent->var_on_error) {
4183 struct arg arg;
4184
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004185 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Fauletb7426d12018-03-21 14:12:17 +01004186 curagent->var_pfx, curagent->var_on_error);
4187
4188 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004189 arg.data.str.area = trash.area;
4190 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004191 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Fauletb7426d12018-03-21 14:12:17 +01004192 if (!vars_check_arg(&arg, err)) {
4193 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4194 curagent->id, curagent->var_pfx, curagent->var_on_error, *err);
4195 goto error;
4196 }
4197 }
4198
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004199 if (curagent->var_t_process) {
4200 struct arg arg;
4201
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004202 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004203 curagent->var_pfx, curagent->var_t_process);
4204
4205 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004206 arg.data.str.area = trash.area;
4207 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004208 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004209 if (!vars_check_arg(&arg, err)) {
4210 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4211 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4212 goto error;
4213 }
4214 }
4215
4216 if (curagent->var_t_total) {
4217 struct arg arg;
4218
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004219 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004220 curagent->var_pfx, curagent->var_t_total);
4221
4222 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004223 arg.data.str.area = trash.area;
4224 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004225 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004226 if (!vars_check_arg(&arg, err)) {
4227 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4228 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4229 goto error;
4230 }
4231 }
4232
Christopher Faulet11610f32017-09-21 10:23:10 +02004233 if (LIST_ISEMPTY(&curmphs) && LIST_ISEMPTY(&curgphs)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004234 ha_warning("Proxy '%s': No message/group used by SPOE agent '%s' declared at %s:%d.\n",
4235 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004236 goto finish;
4237 }
4238
Christopher Faulet11610f32017-09-21 10:23:10 +02004239 /* Replace placeholders by the corresponding messages for the SPOE
4240 * agent */
4241 list_for_each_entry(ph, &curmphs, list) {
4242 list_for_each_entry(msg, &curmsgs, list) {
Christopher Fauleta21b0642017-01-09 16:56:23 +01004243 struct spoe_arg *arg;
4244 unsigned int where;
4245
Christopher Faulet11610f32017-09-21 10:23:10 +02004246 if (!strcmp(msg->id, ph->id)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004247 if ((px->cap & (PR_CAP_FE|PR_CAP_BE)) == (PR_CAP_FE|PR_CAP_BE)) {
4248 if (msg->event == SPOE_EV_ON_TCP_REQ_BE)
4249 msg->event = SPOE_EV_ON_TCP_REQ_FE;
4250 if (msg->event == SPOE_EV_ON_HTTP_REQ_BE)
4251 msg->event = SPOE_EV_ON_HTTP_REQ_FE;
4252 }
4253 if (!(px->cap & PR_CAP_FE) && (msg->event == SPOE_EV_ON_CLIENT_SESS ||
4254 msg->event == SPOE_EV_ON_TCP_REQ_FE ||
4255 msg->event == SPOE_EV_ON_HTTP_REQ_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004256 ha_warning("Proxy '%s': frontend event used on a backend proxy at %s:%d.\n",
4257 px->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004258 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004259 }
4260 if (msg->event == SPOE_EV_NONE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004261 ha_warning("Proxy '%s': Ignore SPOE message '%s' without event at %s:%d.\n",
4262 px->id, msg->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004263 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004264 }
Christopher Fauleta21b0642017-01-09 16:56:23 +01004265
4266 where = 0;
4267 switch (msg->event) {
4268 case SPOE_EV_ON_CLIENT_SESS:
4269 where |= SMP_VAL_FE_CON_ACC;
4270 break;
4271
4272 case SPOE_EV_ON_TCP_REQ_FE:
4273 where |= SMP_VAL_FE_REQ_CNT;
4274 break;
4275
4276 case SPOE_EV_ON_HTTP_REQ_FE:
4277 where |= SMP_VAL_FE_HRQ_HDR;
4278 break;
4279
4280 case SPOE_EV_ON_TCP_REQ_BE:
4281 if (px->cap & PR_CAP_FE)
4282 where |= SMP_VAL_FE_REQ_CNT;
4283 if (px->cap & PR_CAP_BE)
4284 where |= SMP_VAL_BE_REQ_CNT;
4285 break;
4286
4287 case SPOE_EV_ON_HTTP_REQ_BE:
4288 if (px->cap & PR_CAP_FE)
4289 where |= SMP_VAL_FE_HRQ_HDR;
4290 if (px->cap & PR_CAP_BE)
4291 where |= SMP_VAL_BE_HRQ_HDR;
4292 break;
4293
4294 case SPOE_EV_ON_SERVER_SESS:
4295 where |= SMP_VAL_BE_SRV_CON;
4296 break;
4297
4298 case SPOE_EV_ON_TCP_RSP:
4299 if (px->cap & PR_CAP_FE)
4300 where |= SMP_VAL_FE_RES_CNT;
4301 if (px->cap & PR_CAP_BE)
4302 where |= SMP_VAL_BE_RES_CNT;
4303 break;
4304
4305 case SPOE_EV_ON_HTTP_RSP:
4306 if (px->cap & PR_CAP_FE)
4307 where |= SMP_VAL_FE_HRS_HDR;
4308 if (px->cap & PR_CAP_BE)
4309 where |= SMP_VAL_BE_HRS_HDR;
4310 break;
4311
4312 default:
4313 break;
4314 }
4315
4316 list_for_each_entry(arg, &msg->args, list) {
4317 if (!(arg->expr->fetch->val & where)) {
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004318 memprintf(err, "Ignore SPOE message '%s' at %s:%d: "
Christopher Fauleta21b0642017-01-09 16:56:23 +01004319 "some args extract information from '%s', "
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004320 "none of which is available here ('%s')",
4321 msg->id, msg->conf.file, msg->conf.line,
Christopher Fauleta21b0642017-01-09 16:56:23 +01004322 sample_ckp_names(arg->expr->fetch->use),
4323 sample_ckp_names(where));
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004324 goto error;
Christopher Fauleta21b0642017-01-09 16:56:23 +01004325 }
4326 }
4327
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004328 msg->agent = curagent;
Christopher Faulet11610f32017-09-21 10:23:10 +02004329 LIST_ADDQ(&curagent->events[msg->event], &msg->by_evt);
4330 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004331 }
4332 }
4333 memprintf(err, "SPOE agent '%s' try to use undefined SPOE message '%s' at %s:%d",
Christopher Faulet11610f32017-09-21 10:23:10 +02004334 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004335 goto error;
Christopher Faulet11610f32017-09-21 10:23:10 +02004336 next_mph:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004337 continue;
4338 }
4339
Christopher Faulet11610f32017-09-21 10:23:10 +02004340 /* Replace placeholders by the corresponding groups for the SPOE
4341 * agent */
4342 list_for_each_entry(ph, &curgphs, list) {
4343 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4344 if (!strcmp(grp->id, ph->id)) {
4345 grp->agent = curagent;
4346 LIST_DEL(&grp->list);
4347 LIST_ADDQ(&curagent->groups, &grp->list);
4348 goto next_aph;
4349 }
4350 }
4351 memprintf(err, "SPOE agent '%s' try to use undefined SPOE group '%s' at %s:%d",
4352 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
4353 goto error;
4354 next_aph:
4355 continue;
4356 }
4357
4358 /* Replace placeholders by the corresponding message for each SPOE
4359 * group of the SPOE agent */
4360 list_for_each_entry(grp, &curagent->groups, list) {
4361 list_for_each_entry_safe(ph, phback, &grp->phs, list) {
4362 list_for_each_entry(msg, &curmsgs, list) {
4363 if (!strcmp(msg->id, ph->id)) {
4364 if (msg->group != NULL) {
4365 memprintf(err, "SPOE message '%s' already belongs to "
4366 "the SPOE group '%s' declare at %s:%d",
4367 msg->id, msg->group->id,
4368 msg->group->conf.file,
4369 msg->group->conf.line);
4370 goto error;
4371 }
4372
4373 /* Scope for arguments are not checked for now. We will check
4374 * them only if a rule use the corresponding SPOE group. */
4375 msg->agent = curagent;
4376 msg->group = grp;
4377 LIST_DEL(&ph->list);
4378 LIST_ADDQ(&grp->messages, &msg->by_grp);
4379 goto next_mph_grp;
4380 }
4381 }
4382 memprintf(err, "SPOE group '%s' try to use undefined SPOE message '%s' at %s:%d",
4383 grp->id, ph->id, curagent->conf.file, curagent->conf.line);
4384 goto error;
4385 next_mph_grp:
4386 continue;
4387 }
4388 }
4389
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004390 finish:
Christopher Faulet11610f32017-09-21 10:23:10 +02004391 /* move curmsgs to the agent message list */
4392 curmsgs.n->p = &curagent->messages;
4393 curmsgs.p->n = &curagent->messages;
4394 curagent->messages = curmsgs;
4395 LIST_INIT(&curmsgs);
4396
Christopher Faulet7ee86672017-09-19 11:08:28 +02004397 conf->id = strdup(engine ? engine : curagent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004398 conf->agent = curagent;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004399
4400 /* Start agent's proxy initialization here. It will be finished during
4401 * the filter init. */
4402 memset(&conf->agent_fe, 0, sizeof(conf->agent_fe));
4403 init_new_proxy(&conf->agent_fe);
4404 conf->agent_fe.id = conf->agent->id;
4405 conf->agent_fe.parent = conf->agent;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004406 conf->agent_fe.options |= curpxopts;
4407 conf->agent_fe.options2 |= curpxopts2;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004408
4409 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4410 LIST_DEL(&logsrv->list);
4411 LIST_ADDQ(&conf->agent_fe.logsrvs, &logsrv->list);
4412 }
4413
Christopher Faulet11610f32017-09-21 10:23:10 +02004414 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4415 LIST_DEL(&ph->list);
4416 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004417 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004418 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4419 LIST_DEL(&ph->list);
4420 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004421 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004422 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4423 struct arg arg;
4424
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004425 trash.data = snprintf(trash.area, trash.size, "proc.%s.%s",
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004426 curagent->var_pfx, vph->name);
4427
4428 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004429 arg.data.str.area = trash.area;
4430 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004431 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004432 if (!vars_check_arg(&arg, err)) {
4433 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4434 curagent->id, curagent->var_pfx, vph->name, *err);
4435 goto error;
4436 }
4437
4438 LIST_DEL(&vph->list);
4439 free(vph->name);
4440 free(vph);
4441 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004442 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4443 LIST_DEL(&grp->list);
4444 spoe_release_group(grp);
4445 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004446 *cur_arg = pos;
Christopher Faulet3b386a32017-02-23 10:17:15 +01004447 fconf->id = spoe_filter_id;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004448 fconf->ops = &spoe_ops;
4449 fconf->conf = conf;
4450 return 0;
4451
4452 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01004453 spoe_release_agent(curagent);
Christopher Faulet11610f32017-09-21 10:23:10 +02004454 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4455 LIST_DEL(&ph->list);
4456 spoe_release_placeholder(ph);
4457 }
4458 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4459 LIST_DEL(&ph->list);
4460 spoe_release_placeholder(ph);
4461 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004462 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4463 LIST_DEL(&vph->list);
4464 free(vph->name);
4465 free(vph);
4466 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004467 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4468 LIST_DEL(&grp->list);
4469 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004470 }
4471 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
4472 LIST_DEL(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01004473 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004474 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004475 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4476 LIST_DEL(&logsrv->list);
4477 free(logsrv);
4478 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004479 free(conf);
4480 return -1;
4481}
4482
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004483/* Send message of a SPOE group. This is the action_ptr callback of a rule
4484 * associated to a "send-spoe-group" action.
4485 *
4486 * It returns ACT_RET_CONT is processing is finished without error, it returns
4487 * ACT_RET_YIELD if the action is in progress. Otherwise it returns
4488 * ACT_RET_ERR. */
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004489static enum act_return
4490spoe_send_group(struct act_rule *rule, struct proxy *px,
4491 struct session *sess, struct stream *s, int flags)
4492{
4493 struct filter *filter;
4494 struct spoe_agent *agent = NULL;
4495 struct spoe_group *group = NULL;
4496 struct spoe_context *ctx = NULL;
4497 int ret, dir;
4498
4499 list_for_each_entry(filter, &s->strm_flt.filters, list) {
4500 if (filter->config == rule->arg.act.p[0]) {
4501 agent = rule->arg.act.p[2];
4502 group = rule->arg.act.p[3];
4503 ctx = filter->ctx;
4504 break;
4505 }
4506 }
4507 if (agent == NULL || group == NULL || ctx == NULL)
4508 return ACT_RET_ERR;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004509 if (ctx->state == SPOE_CTX_ST_NONE)
4510 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004511
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004512 switch (rule->from) {
4513 case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break;
4514 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
4515 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
4516 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
4517 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
4518 default:
4519 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4520 " - internal error while execute spoe-send-group\n",
4521 (int)now.tv_sec, (int)now.tv_usec, agent->id,
4522 __FUNCTION__, s);
4523 send_log(px, LOG_ERR, "SPOE: [%s] internal error while execute spoe-send-group\n",
4524 agent->id);
4525 return ACT_RET_CONT;
4526 }
4527
4528 ret = spoe_process_group(s, ctx, group, dir);
4529 if (ret == 1)
4530 return ACT_RET_CONT;
4531 else if (ret == 0) {
4532 if (flags & ACT_FLAG_FINAL) {
4533 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4534 " - failed to process group '%s': interrupted by caller\n",
4535 (int)now.tv_sec, (int)now.tv_usec,
4536 agent->id, __FUNCTION__, s, group->id);
4537 ctx->status_code = SPOE_CTX_ERR_INTERRUPT;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01004538 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02004539 spoe_handle_processing_error(s, agent, ctx, dir);
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004540 return ACT_RET_CONT;
4541 }
4542 return ACT_RET_YIELD;
4543 }
4544 else
4545 return ACT_RET_ERR;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004546}
4547
4548/* Check an "send-spoe-group" action. Here, we'll try to find the real SPOE
4549 * group associated to <rule>. The format of an rule using 'send-spoe-group'
4550 * action should be:
4551 *
4552 * (http|tcp)-(request|response) send-spoe-group <engine-id> <group-id>
4553 *
4554 * So, we'll loop on each configured SPOE filter for the proxy <px> to find the
4555 * SPOE engine matching <engine-id>. And then, we'll try to find the good group
4556 * matching <group-id>. Finally, we'll check all messages referenced by the SPOE
4557 * group.
4558 *
4559 * The function returns 1 in success case, otherwise, it returns 0 and err is
4560 * filled.
4561 */
4562static int
4563check_send_spoe_group(struct act_rule *rule, struct proxy *px, char **err)
4564{
4565 struct flt_conf *fconf;
4566 struct spoe_config *conf;
4567 struct spoe_agent *agent = NULL;
4568 struct spoe_group *group;
4569 struct spoe_message *msg;
4570 char *engine_id = rule->arg.act.p[0];
4571 char *group_id = rule->arg.act.p[1];
4572 unsigned int where = 0;
4573
4574 switch (rule->from) {
4575 case ACT_F_TCP_REQ_SES: where = SMP_VAL_FE_SES_ACC; break;
4576 case ACT_F_TCP_REQ_CNT: where = SMP_VAL_FE_REQ_CNT; break;
4577 case ACT_F_TCP_RES_CNT: where = SMP_VAL_BE_RES_CNT; break;
4578 case ACT_F_HTTP_REQ: where = SMP_VAL_FE_HRQ_HDR; break;
4579 case ACT_F_HTTP_RES: where = SMP_VAL_BE_HRS_HDR; break;
4580 default:
4581 memprintf(err,
4582 "internal error, unexpected rule->from=%d, please report this bug!",
4583 rule->from);
4584 goto error;
4585 }
4586
4587 /* Try to find the SPOE engine by checking all SPOE filters for proxy
4588 * <px> */
4589 list_for_each_entry(fconf, &px->filter_configs, list) {
4590 conf = fconf->conf;
4591
4592 /* This is not an SPOE filter */
4593 if (fconf->id != spoe_filter_id)
4594 continue;
4595
4596 /* This is the good engine */
4597 if (!strcmp(conf->id, engine_id)) {
4598 agent = conf->agent;
4599 break;
4600 }
4601 }
4602 if (agent == NULL) {
4603 memprintf(err, "unable to find SPOE engine '%s' used by the send-spoe-group '%s'",
4604 engine_id, group_id);
4605 goto error;
4606 }
4607
4608 /* Try to find the right group */
4609 list_for_each_entry(group, &agent->groups, list) {
4610 /* This is the good group */
4611 if (!strcmp(group->id, group_id))
4612 break;
4613 }
4614 if (&group->list == &agent->groups) {
4615 memprintf(err, "unable to find SPOE group '%s' into SPOE engine '%s' configuration",
4616 group_id, engine_id);
4617 goto error;
4618 }
4619
4620 /* Ok, we found the group, we need to check messages and their
4621 * arguments */
4622 list_for_each_entry(msg, &group->messages, by_grp) {
4623 struct spoe_arg *arg;
4624
4625 list_for_each_entry(arg, &msg->args, list) {
4626 if (!(arg->expr->fetch->val & where)) {
4627 memprintf(err, "Invalid SPOE message '%s' used by SPOE group '%s' at %s:%d: "
4628 "some args extract information from '%s',"
4629 "none of which is available here ('%s')",
4630 msg->id, group->id, msg->conf.file, msg->conf.line,
4631 sample_ckp_names(arg->expr->fetch->use),
4632 sample_ckp_names(where));
4633 goto error;
4634 }
4635 }
4636 }
4637
4638 free(engine_id);
4639 free(group_id);
4640 rule->arg.act.p[0] = fconf; /* Associate filter config with the rule */
4641 rule->arg.act.p[1] = conf; /* Associate SPOE config with the rule */
4642 rule->arg.act.p[2] = agent; /* Associate SPOE agent with the rule */
4643 rule->arg.act.p[3] = group; /* Associate SPOE group with the rule */
4644 return 1;
4645
4646 error:
4647 free(engine_id);
4648 free(group_id);
4649 return 0;
4650}
4651
4652/* Parse 'send-spoe-group' action following the format:
4653 *
4654 * ... send-spoe-group <engine-id> <group-id>
4655 *
4656 * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error
4657 * message. Otherwise, it returns ACT_RET_PRS_OK and parsing engine and group
4658 * ids are saved and used later, when the rule will be checked.
4659 */
4660static enum act_parse_ret
4661parse_send_spoe_group(const char **args, int *orig_arg, struct proxy *px,
4662 struct act_rule *rule, char **err)
4663{
4664 if (!*args[*orig_arg] || !*args[*orig_arg+1] ||
4665 (*args[*orig_arg+2] && strcmp(args[*orig_arg+2], "if") != 0 && strcmp(args[*orig_arg+2], "unless") != 0)) {
4666 memprintf(err, "expects 2 arguments: <engine-id> <group-id>");
4667 return ACT_RET_PRS_ERR;
4668 }
4669 rule->arg.act.p[0] = strdup(args[*orig_arg]); /* Copy the SPOE engine id */
4670 rule->arg.act.p[1] = strdup(args[*orig_arg+1]); /* Cope the SPOE group id */
4671
4672 (*orig_arg) += 2;
4673
4674 rule->action = ACT_CUSTOM;
4675 rule->action_ptr = spoe_send_group;
4676 rule->check_ptr = check_send_spoe_group;
4677 return ACT_RET_PRS_OK;
4678}
4679
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004680
4681/* Declare the filter parser for "spoe" keyword */
4682static struct flt_kw_list flt_kws = { "SPOE", { }, {
4683 { "spoe", parse_spoe_flt, NULL },
4684 { NULL, NULL, NULL },
4685 }
4686};
4687
Willy Tarreau0108d902018-11-25 19:14:37 +01004688INITCALL1(STG_REGISTER, flt_register_keywords, &flt_kws);
4689
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004690/* Delcate the action parser for "spoe-action" keyword */
4691static struct action_kw_list tcp_req_action_kws = { { }, {
4692 { "send-spoe-group", parse_send_spoe_group },
4693 { /* END */ },
4694 }
4695};
Willy Tarreau0108d902018-11-25 19:14:37 +01004696
4697INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_action_kws);
4698
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004699static struct action_kw_list tcp_res_action_kws = { { }, {
4700 { "send-spoe-group", parse_send_spoe_group },
4701 { /* END */ },
4702 }
4703};
Willy Tarreau0108d902018-11-25 19:14:37 +01004704
4705INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_action_kws);
4706
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004707static struct action_kw_list http_req_action_kws = { { }, {
4708 { "send-spoe-group", parse_send_spoe_group },
4709 { /* END */ },
4710 }
4711};
Willy Tarreau0108d902018-11-25 19:14:37 +01004712
4713INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_action_kws);
4714
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004715static struct action_kw_list http_res_action_kws = { { }, {
4716 { "send-spoe-group", parse_send_spoe_group },
4717 { /* END */ },
4718 }
4719};
4720
Willy Tarreau0108d902018-11-25 19:14:37 +01004721INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_action_kws);