blob: 437f025a1b5be5f44a356a880938c651c5556c65 [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 */
1278 if (spoe_appctx->task) {
1279 task_delete(spoe_appctx->task);
1280 task_free(spoe_appctx->task);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001281 }
1282
Christopher Faulet8ef75252017-02-20 22:56:03 +01001283 /* Notify all waiting streams */
1284 list_for_each_entry_safe(ctx, back, &spoe_appctx->waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001285 LIST_DEL(&ctx->list);
1286 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001287 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001288 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001289 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001290 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001291 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001292 }
1293
Christopher Faulet8ef75252017-02-20 22:56:03 +01001294 /* If the applet was processing a fragmented frame, notify the
1295 * corresponding stream. */
1296 if (spoe_appctx->frag_ctx.ctx) {
1297 ctx = spoe_appctx->frag_ctx.ctx;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001298 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001299 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001300 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001301 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1302 }
1303
Christopher Faulet8ef75252017-02-20 22:56:03 +01001304 /* Release allocated memory */
1305 spoe_release_buffer(&spoe_appctx->buffer,
1306 &spoe_appctx->buffer_wait);
Willy Tarreaubafbe012017-11-24 17:34:44 +01001307 pool_free(pool_head_spoe_appctx, spoe_appctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001308
Christopher Faulet24289f22017-09-25 14:48:02 +02001309 if (!LIST_ISEMPTY(&agent->rt[tid].applets))
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001310 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001311
Christopher Faulet8ef75252017-02-20 22:56:03 +01001312 /* If this was the last running applet, notify all waiting streams */
Christopher Faulet24289f22017-09-25 14:48:02 +02001313 list_for_each_entry_safe(ctx, back, &agent->rt[tid].sending_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001314 LIST_DEL(&ctx->list);
1315 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001316 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001317 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001318 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001319 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001320 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001321 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001322 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001323 LIST_DEL(&ctx->list);
1324 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001325 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001326 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001327 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001328 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001329 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1330 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001331
1332 end:
1333 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001334 agent->rt[tid].frame_size = agent->max_frame_size;
1335 list_for_each_entry(spoe_appctx, &agent->rt[tid].applets, list)
1336 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, spoe_appctx->max_frame_size);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001337}
1338
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001339static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001340spoe_handle_connect_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001341{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001342 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001343 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001344 char *frame, *buf;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001345 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001346
Christopher Fauleta1cda022016-12-21 08:58:06 +01001347 if (si->state <= SI_ST_CON) {
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001348 si_rx_endp_more(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001349 task_wakeup(si_strm(si)->task, TASK_WOKEN_MSG);
1350 goto stop;
1351 }
Christopher Fauletb067b062017-01-04 16:39:11 +01001352 if (si->state != SI_ST_EST) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001353 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001354 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001355 }
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 si_oc(si)->flags |= CF_READ_DONTWAIT;
1948 task_wakeup(si_strm(si)->task, TASK_WOKEN_IO);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001949}
1950
1951struct applet spoe_applet = {
1952 .obj_type = OBJ_TYPE_APPLET,
1953 .name = "<SPOE>", /* used for logging */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001954 .fct = spoe_handle_appctx,
1955 .release = spoe_release_appctx,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001956};
1957
1958/* Create a SPOE applet. On success, the created applet is returned, else
1959 * NULL. */
1960static struct appctx *
Christopher Faulet8ef75252017-02-20 22:56:03 +01001961spoe_create_appctx(struct spoe_config *conf)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001962{
1963 struct appctx *appctx;
1964 struct session *sess;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001965 struct stream *strm;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001966
Emeric Brun1138fd02017-06-19 12:38:55 +02001967 if ((appctx = appctx_new(&spoe_applet, tid_bit)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001968 goto out_error;
1969
Willy Tarreaubafbe012017-11-24 17:34:44 +01001970 appctx->ctx.spoe.ptr = pool_alloc_dirty(pool_head_spoe_appctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001971 if (SPOE_APPCTX(appctx) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001972 goto out_free_appctx;
Willy Tarreaubafbe012017-11-24 17:34:44 +01001973 memset(appctx->ctx.spoe.ptr, 0, pool_head_spoe_appctx->size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001974
Christopher Faulet42bfa462017-01-04 14:14:19 +01001975 appctx->st0 = SPOE_APPCTX_ST_CONNECT;
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01001976 if ((SPOE_APPCTX(appctx)->task = task_new(tid_bit)) == NULL)
Christopher Faulet42bfa462017-01-04 14:14:19 +01001977 goto out_free_spoe_appctx;
1978
1979 SPOE_APPCTX(appctx)->owner = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001980 SPOE_APPCTX(appctx)->task->process = spoe_process_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001981 SPOE_APPCTX(appctx)->task->context = appctx;
1982 SPOE_APPCTX(appctx)->agent = conf->agent;
1983 SPOE_APPCTX(appctx)->version = 0;
1984 SPOE_APPCTX(appctx)->max_frame_size = conf->agent->max_frame_size;
1985 SPOE_APPCTX(appctx)->flags = 0;
Christopher Fauletb067b062017-01-04 16:39:11 +01001986 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001987 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001988 SPOE_APPCTX(appctx)->cur_fpa = 0;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001989
1990 LIST_INIT(&SPOE_APPCTX(appctx)->buffer_wait.list);
1991 SPOE_APPCTX(appctx)->buffer_wait.target = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001992 SPOE_APPCTX(appctx)->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001993
1994 LIST_INIT(&SPOE_APPCTX(appctx)->list);
1995 LIST_INIT(&SPOE_APPCTX(appctx)->waiting_queue);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001996
Willy Tarreau5820a362016-12-22 15:59:02 +01001997 sess = session_new(&conf->agent_fe, NULL, &appctx->obj_type);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001998 if (!sess)
1999 goto out_free_spoe;
2000
Willy Tarreau87787ac2017-08-28 16:22:54 +02002001 if ((strm = stream_new(sess, &appctx->obj_type)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002002 goto out_free_sess;
2003
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002004 stream_set_backend(strm, conf->agent->b.be);
2005
2006 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002007 si_cant_get(&strm->si[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002008 appctx_wakeup(appctx);
2009
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002010 strm->do_log = NULL;
2011 strm->res.flags |= CF_READ_DONTWAIT;
2012
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002013 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02002014 LIST_ADDQ(&conf->agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002015 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002016 _HA_ATOMIC_ADD(&conf->agent->counters.applets, 1);
Emeric Brun5f77fef2017-05-29 15:26:51 +02002017
Emeric Brunc60def82017-09-27 14:59:38 +02002018 task_wakeup(SPOE_APPCTX(appctx)->task, TASK_WOKEN_INIT);
Willy Tarreau87787ac2017-08-28 16:22:54 +02002019 task_wakeup(strm->task, TASK_WOKEN_INIT);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002020 return appctx;
2021
2022 /* Error unrolling */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002023 out_free_sess:
2024 session_free(sess);
2025 out_free_spoe:
Christopher Faulet42bfa462017-01-04 14:14:19 +01002026 task_free(SPOE_APPCTX(appctx)->task);
2027 out_free_spoe_appctx:
Willy Tarreaubafbe012017-11-24 17:34:44 +01002028 pool_free(pool_head_spoe_appctx, SPOE_APPCTX(appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002029 out_free_appctx:
2030 appctx_free(appctx);
2031 out_error:
2032 return NULL;
2033}
2034
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002035static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002036spoe_queue_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002037{
2038 struct spoe_config *conf = FLT_CONF(ctx->filter);
2039 struct spoe_agent *agent = conf->agent;
2040 struct appctx *appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002041 struct spoe_appctx *spoe_appctx;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002042
Christopher Fauleta1cda022016-12-21 08:58:06 +01002043 /* Check if we need to create a new SPOE applet or not. */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002044 if (!eb_is_empty(&agent->rt[tid].idle_applets) &&
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002045 agent->rt[tid].processing < read_freq_ctr(&agent->rt[tid].processing_per_sec))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002046 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002047
2048 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauleta1cda022016-12-21 08:58:06 +01002049 " - try to create new SPOE appctx\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002050 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
2051 ctx->strm);
2052
Christopher Fauleta1cda022016-12-21 08:58:06 +01002053 /* Do not try to create a new applet if there is no server up for the
2054 * agent's backend. */
2055 if (!agent->b.be->srv_act && !agent->b.be->srv_bck) {
2056 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2057 " - cannot create SPOE appctx: no server up\n",
2058 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2059 __FUNCTION__, ctx->strm);
2060 goto end;
2061 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002062
Christopher Fauleta1cda022016-12-21 08:58:06 +01002063 /* Do not try to create a new applet if we have reached the maximum of
2064 * connection per seconds */
Christopher Faulet48026722016-11-16 15:01:12 +01002065 if (agent->cps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002066 if (!freq_ctr_remain(&agent->rt[tid].conn_per_sec, agent->cps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002067 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2068 " - cannot create SPOE appctx: max CPS reached\n",
2069 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2070 __FUNCTION__, ctx->strm);
2071 goto end;
2072 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002073 }
2074
Christopher Faulet8ef75252017-02-20 22:56:03 +01002075 appctx = spoe_create_appctx(conf);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002076 if (appctx == NULL) {
2077 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2078 " - failed to create SPOE appctx\n",
2079 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2080 __FUNCTION__, ctx->strm);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02002081 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01002082 "SPOE: [%s] failed to create SPOE applet\n",
2083 agent->id);
2084
Christopher Fauleta1cda022016-12-21 08:58:06 +01002085 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002086 }
2087
Christopher Fauleta1cda022016-12-21 08:58:06 +01002088 /* Increase the per-process number of cumulated connections */
2089 if (agent->cps_max > 0)
Christopher Faulet24289f22017-09-25 14:48:02 +02002090 update_freq_ctr(&agent->rt[tid].conn_per_sec, 1);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002091
Christopher Fauleta1cda022016-12-21 08:58:06 +01002092 end:
2093 /* The only reason to return an error is when there is no applet */
Christopher Faulet24289f22017-09-25 14:48:02 +02002094 if (LIST_ISEMPTY(&agent->rt[tid].applets)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002095 ctx->status_code = SPOE_CTX_ERR_RES;
2096 return -1;
2097 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002098
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002099 /* Add the SPOE context in the sending queue */
Christopher Faulet24289f22017-09-25 14:48:02 +02002100 LIST_ADDQ(&agent->rt[tid].sending_queue, &ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002101 _HA_ATOMIC_ADD(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002102 spoe_update_stat_time(&ctx->stats.tv_request, &ctx->stats.t_request);
2103 ctx->stats.tv_queue = now;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002104
2105 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002106 " - Add stream in sending queue"
Christopher Faulet68db0232018-04-06 11:34:12 +02002107 " - applets=%u - idles=%u - processing=%u\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002108 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
Christopher Faulet68db0232018-04-06 11:34:12 +02002109 ctx->strm, agent->counters.applets, agent->counters.idles,
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002110 agent->rt[tid].processing);
Christopher Fauletf7a30922016-11-10 15:04:51 +01002111
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002112 /* Finally try to wakeup an IDLE applet. */
2113 if (!eb_is_empty(&agent->rt[tid].idle_applets)) {
2114 struct eb32_node *node;
2115
2116 node = eb32_first(&agent->rt[tid].idle_applets);
2117 spoe_appctx = eb32_entry(node, struct spoe_appctx, node);
2118 if (node && spoe_appctx) {
2119 eb32_delete(&spoe_appctx->node);
2120 spoe_appctx->node.key++;
2121 eb32_insert(&agent->rt[tid].idle_applets, &spoe_appctx->node);
2122 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002123 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002124 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002125 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002126}
2127
2128/***************************************************************************
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002129 * Functions that encode SPOE messages
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002130 **************************************************************************/
Christopher Faulet10e37672017-09-21 16:38:22 +02002131/* Encode a SPOE message. Info in <ctx->frag_ctx>, if any, are used to handle
2132 * fragmented_content. If the next message can be processed, it returns 0. If
2133 * the message is too big, it returns -1.*/
2134static int
2135spoe_encode_message(struct stream *s, struct spoe_context *ctx,
2136 struct spoe_message *msg, int dir,
2137 char **buf, char *end)
2138{
2139 struct sample *smp;
2140 struct spoe_arg *arg;
2141 int ret;
2142
2143 if (msg->cond) {
2144 ret = acl_exec_cond(msg->cond, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2145 ret = acl_pass(ret);
2146 if (msg->cond->pol == ACL_COND_UNLESS)
2147 ret = !ret;
2148
2149 /* the rule does not match */
2150 if (!ret)
2151 goto next;
2152 }
2153
2154 /* Resume encoding of a SPOE argument */
2155 if (ctx->frag_ctx.curarg != NULL) {
2156 arg = ctx->frag_ctx.curarg;
2157 goto encode_argument;
2158 }
2159
2160 if (ctx->frag_ctx.curoff != UINT_MAX)
2161 goto encode_msg_payload;
2162
2163 /* Check if there is enough space for the message name and the
2164 * number of arguments. It implies <msg->id_len> is encoded on 2
2165 * bytes, at most (< 2288). */
2166 if (*buf + 2 + msg->id_len + 1 > end)
2167 goto too_big;
2168
2169 /* Encode the message name */
2170 if (spoe_encode_buffer(msg->id, msg->id_len, buf, end) == -1)
2171 goto too_big;
2172
2173 /* Set the number of arguments for this message */
2174 **buf = msg->nargs;
2175 (*buf)++;
2176
2177 ctx->frag_ctx.curoff = 0;
2178 encode_msg_payload:
2179
2180 /* Loop on arguments */
2181 list_for_each_entry(arg, &msg->args, list) {
2182 ctx->frag_ctx.curarg = arg;
2183 ctx->frag_ctx.curoff = UINT_MAX;
2184
2185 encode_argument:
2186 if (ctx->frag_ctx.curoff != UINT_MAX)
2187 goto encode_arg_value;
2188
Joseph Herlantf7f60312018-11-15 13:46:49 -08002189 /* Encode the argument name as a string. It can by NULL */
Christopher Faulet10e37672017-09-21 16:38:22 +02002190 if (spoe_encode_buffer(arg->name, arg->name_len, buf, end) == -1)
2191 goto too_big;
2192
2193 ctx->frag_ctx.curoff = 0;
2194 encode_arg_value:
2195
Joseph Herlantf7f60312018-11-15 13:46:49 -08002196 /* Fetch the argument value */
Christopher Faulet10e37672017-09-21 16:38:22 +02002197 smp = sample_process(s->be, s->sess, s, dir|SMP_OPT_FINAL, arg->expr, NULL);
2198 ret = spoe_encode_data(smp, &ctx->frag_ctx.curoff, buf, end);
2199 if (ret == -1 || ctx->frag_ctx.curoff)
2200 goto too_big;
2201 }
2202
2203 next:
2204 return 0;
2205
2206 too_big:
2207 return -1;
2208}
2209
Christopher Fauletc718b822017-09-21 16:50:56 +02002210/* Encode list of SPOE messages. Info in <ctx->frag_ctx>, if any, are used to
2211 * handle fragmented content. On success it returns 1. If an error occurred, -1
2212 * is returned. If nothing has been encoded, it returns 0 (this is only possible
2213 * for unfragmented payload). */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002214static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002215spoe_encode_messages(struct stream *s, struct spoe_context *ctx,
Christopher Fauletc718b822017-09-21 16:50:56 +02002216 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002217{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002218 struct spoe_config *conf = FLT_CONF(ctx->filter);
2219 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002220 struct spoe_message *msg;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002221 char *p, *end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002222
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002223 p = b_head(&ctx->buffer);
Christopher Faulet24289f22017-09-25 14:48:02 +02002224 end = p + agent->rt[tid].frame_size - FRAME_HDR_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002225
Christopher Fauletc718b822017-09-21 16:50:56 +02002226 if (type == SPOE_MSGS_BY_EVENT) { /* Loop on messages by event */
2227 /* Resume encoding of a SPOE message */
2228 if (ctx->frag_ctx.curmsg != NULL) {
2229 msg = ctx->frag_ctx.curmsg;
2230 goto encode_evt_message;
2231 }
2232
2233 list_for_each_entry(msg, messages, by_evt) {
2234 ctx->frag_ctx.curmsg = msg;
2235 ctx->frag_ctx.curarg = NULL;
2236 ctx->frag_ctx.curoff = UINT_MAX;
2237
2238 encode_evt_message:
2239 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2240 goto too_big;
2241 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002242 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002243 else if (type == SPOE_MSGS_BY_GROUP) { /* Loop on messages by group */
2244 /* Resume encoding of a SPOE message */
2245 if (ctx->frag_ctx.curmsg != NULL) {
2246 msg = ctx->frag_ctx.curmsg;
2247 goto encode_grp_message;
2248 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002249
Christopher Fauletc718b822017-09-21 16:50:56 +02002250 list_for_each_entry(msg, messages, by_grp) {
2251 ctx->frag_ctx.curmsg = msg;
2252 ctx->frag_ctx.curarg = NULL;
2253 ctx->frag_ctx.curoff = UINT_MAX;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002254
Christopher Fauletc718b822017-09-21 16:50:56 +02002255 encode_grp_message:
2256 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2257 goto too_big;
2258 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002259 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002260 else
2261 goto skip;
2262
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002263
Christopher Faulet57583e42017-09-04 15:41:09 +02002264 /* nothing has been encoded for an unfragmented payload */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002265 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) && p == b_head(&ctx->buffer))
Christopher Faulet57583e42017-09-04 15:41:09 +02002266 goto skip;
2267
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002268 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002269 " - encode %s messages - spoe_appctx=%p"
2270 "- max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002271 (int)now.tv_sec, (int)now.tv_usec,
2272 agent->id, __FUNCTION__, s,
2273 ((ctx->flags & SPOE_CTX_FL_FRAGMENTED) ? "last fragment of" : "unfragmented"),
Christopher Fauletfce747b2018-01-24 15:59:32 +01002274 ctx->spoe_appctx, (agent->rt[tid].frame_size - FRAME_HDR_SIZE),
Christopher Faulet45073512018-07-20 10:16:29 +02002275 p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002276
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002277 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002278 ctx->frag_ctx.curmsg = NULL;
2279 ctx->frag_ctx.curarg = NULL;
2280 ctx->frag_ctx.curoff = 0;
2281 ctx->frag_ctx.flags = SPOE_FRM_FL_FIN;
Christopher Faulet57583e42017-09-04 15:41:09 +02002282
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002283 return 1;
2284
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002285 too_big:
Christopher Fauletcecd8522017-02-24 22:11:21 +01002286 if (!(agent->flags & SPOE_FL_SND_FRAGMENTATION)) {
2287 ctx->status_code = SPOE_CTX_ERR_TOO_BIG;
2288 return -1;
2289 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002290
2291 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002292 " - encode fragmented messages - spoe_appctx=%p"
2293 " - curmsg=%p - curarg=%p - curoff=%u"
2294 " - max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002295 (int)now.tv_sec, (int)now.tv_usec,
Christopher Fauletfce747b2018-01-24 15:59:32 +01002296 agent->id, __FUNCTION__, s, ctx->spoe_appctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002297 ctx->frag_ctx.curmsg, ctx->frag_ctx.curarg, ctx->frag_ctx.curoff,
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002298 (agent->rt[tid].frame_size - FRAME_HDR_SIZE), p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002299
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002300 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002301 ctx->flags |= SPOE_CTX_FL_FRAGMENTED;
2302 ctx->frag_ctx.flags &= ~SPOE_FRM_FL_FIN;
2303 return 1;
Christopher Faulet57583e42017-09-04 15:41:09 +02002304
2305 skip:
2306 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2307 " - skip the frame because nothing has been encoded\n",
2308 (int)now.tv_sec, (int)now.tv_usec,
2309 agent->id, __FUNCTION__, s);
2310 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002311}
2312
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002313
2314/***************************************************************************
2315 * Functions that handle SPOE actions
2316 **************************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002317/* Helper function to set a variable */
2318static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002319spoe_set_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002320 struct sample *smp)
2321{
2322 struct spoe_config *conf = FLT_CONF(ctx->filter);
2323 struct spoe_agent *agent = conf->agent;
2324 char varname[64];
2325
2326 memset(varname, 0, sizeof(varname));
2327 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2328 scope, agent->var_pfx, len, name);
Etienne Carriereaec89892017-12-14 09:36:40 +00002329 if (agent->flags & SPOE_FL_FORCE_SET_VAR)
2330 vars_set_by_name(varname, len, smp);
2331 else
2332 vars_set_by_name_ifexist(varname, len, smp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002333}
2334
2335/* Helper function to unset a variable */
2336static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002337spoe_unset_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002338 struct sample *smp)
2339{
2340 struct spoe_config *conf = FLT_CONF(ctx->filter);
2341 struct spoe_agent *agent = conf->agent;
2342 char varname[64];
2343
2344 memset(varname, 0, sizeof(varname));
2345 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2346 scope, agent->var_pfx, len, name);
2347 vars_unset_by_name_ifexist(varname, len, smp);
2348}
2349
2350
Christopher Faulet8ef75252017-02-20 22:56:03 +01002351static inline int
2352spoe_decode_action_set_var(struct stream *s, struct spoe_context *ctx,
2353 char **buf, char *end, int dir)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002354{
Christopher Faulet8ef75252017-02-20 22:56:03 +01002355 char *str, *scope, *p = *buf;
2356 struct sample smp;
2357 uint64_t sz;
2358 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002359
Christopher Faulet8ef75252017-02-20 22:56:03 +01002360 if (p + 2 >= end)
2361 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002362
Christopher Faulet8ef75252017-02-20 22:56:03 +01002363 /* SET-VAR requires 3 arguments */
2364 if (*p++ != 3)
2365 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002366
Christopher Faulet8ef75252017-02-20 22:56:03 +01002367 switch (*p++) {
2368 case SPOE_SCOPE_PROC: scope = "proc"; break;
2369 case SPOE_SCOPE_SESS: scope = "sess"; break;
2370 case SPOE_SCOPE_TXN : scope = "txn"; break;
2371 case SPOE_SCOPE_REQ : scope = "req"; break;
2372 case SPOE_SCOPE_RES : scope = "res"; break;
2373 default: goto skip;
2374 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002375
Christopher Faulet8ef75252017-02-20 22:56:03 +01002376 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2377 goto skip;
2378 memset(&smp, 0, sizeof(smp));
2379 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002380
Christopher Faulet8ef75252017-02-20 22:56:03 +01002381 if (spoe_decode_data(&p, end, &smp) == -1)
2382 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002383
Christopher Faulet8ef75252017-02-20 22:56:03 +01002384 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2385 " - set-var '%s.%s.%.*s'\n",
2386 (int)now.tv_sec, (int)now.tv_usec,
2387 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2388 __FUNCTION__, s, scope,
2389 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2390 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002391
Christopher Faulet8ef75252017-02-20 22:56:03 +01002392 spoe_set_var(ctx, scope, str, sz, &smp);
Christopher Fauletb5cff602016-11-24 14:53:22 +01002393
Christopher Faulet8ef75252017-02-20 22:56:03 +01002394 ret = (p - *buf);
2395 *buf = p;
2396 return ret;
2397 skip:
2398 return 0;
2399}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002400
Christopher Faulet8ef75252017-02-20 22:56:03 +01002401static inline int
2402spoe_decode_action_unset_var(struct stream *s, struct spoe_context *ctx,
2403 char **buf, char *end, int dir)
2404{
2405 char *str, *scope, *p = *buf;
2406 struct sample smp;
2407 uint64_t sz;
2408 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002409
Christopher Faulet8ef75252017-02-20 22:56:03 +01002410 if (p + 2 >= end)
2411 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002412
Christopher Faulet8ef75252017-02-20 22:56:03 +01002413 /* UNSET-VAR requires 2 arguments */
2414 if (*p++ != 2)
2415 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002416
Christopher Faulet8ef75252017-02-20 22:56:03 +01002417 switch (*p++) {
2418 case SPOE_SCOPE_PROC: scope = "proc"; break;
2419 case SPOE_SCOPE_SESS: scope = "sess"; break;
2420 case SPOE_SCOPE_TXN : scope = "txn"; break;
2421 case SPOE_SCOPE_REQ : scope = "req"; break;
2422 case SPOE_SCOPE_RES : scope = "res"; break;
2423 default: goto skip;
2424 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002425
Christopher Faulet8ef75252017-02-20 22:56:03 +01002426 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2427 goto skip;
2428 memset(&smp, 0, sizeof(smp));
2429 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002430
Christopher Faulet8ef75252017-02-20 22:56:03 +01002431 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2432 " - unset-var '%s.%s.%.*s'\n",
2433 (int)now.tv_sec, (int)now.tv_usec,
2434 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2435 __FUNCTION__, s, scope,
2436 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2437 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002438
Christopher Faulet8ef75252017-02-20 22:56:03 +01002439 spoe_unset_var(ctx, scope, str, sz, &smp);
2440
2441 ret = (p - *buf);
2442 *buf = p;
2443 return ret;
2444 skip:
2445 return 0;
2446}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002447
Christopher Faulet8ef75252017-02-20 22:56:03 +01002448/* Process SPOE actions for a specific event. It returns 1 on success. If an
2449 * error occurred, 0 is returned. */
2450static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002451spoe_process_actions(struct stream *s, struct spoe_context *ctx, int dir)
Christopher Faulet8ef75252017-02-20 22:56:03 +01002452{
2453 char *p, *end;
2454 int ret;
2455
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002456 p = b_head(&ctx->buffer);
2457 end = p + b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002458
2459 while (p < end) {
2460 enum spoe_action_type type;
2461
2462 type = *p++;
2463 switch (type) {
2464 case SPOE_ACT_T_SET_VAR:
2465 ret = spoe_decode_action_set_var(s, ctx, &p, end, dir);
2466 if (!ret)
2467 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002468 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002469
Christopher Faulet8ef75252017-02-20 22:56:03 +01002470 case SPOE_ACT_T_UNSET_VAR:
2471 ret = spoe_decode_action_unset_var(s, ctx, &p, end, dir);
2472 if (!ret)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002473 goto skip;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002474 break;
2475
2476 default:
2477 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002478 }
2479 }
2480
2481 return 1;
2482 skip:
2483 return 0;
2484}
2485
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002486/***************************************************************************
2487 * Functions that process SPOE events
2488 **************************************************************************/
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002489static void
2490spoe_update_stats(struct stream *s, struct spoe_agent *agent,
2491 struct spoe_context *ctx, int dir)
2492{
2493 if (!tv_iszero(&ctx->stats.tv_start)) {
2494 spoe_update_stat_time(&ctx->stats.tv_start, &ctx->stats.t_process);
2495 ctx->stats.t_total += ctx->stats.t_process;
2496 tv_zero(&ctx->stats.tv_request);
2497 tv_zero(&ctx->stats.tv_queue);
2498 tv_zero(&ctx->stats.tv_wait);
2499 tv_zero(&ctx->stats.tv_response);
2500 }
2501
2502 if (agent->var_t_process) {
2503 struct sample smp;
2504
2505 memset(&smp, 0, sizeof(smp));
2506 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2507 smp.data.u.sint = ctx->stats.t_process;
2508 smp.data.type = SMP_T_SINT;
2509
2510 spoe_set_var(ctx, "txn", agent->var_t_process,
2511 strlen(agent->var_t_process), &smp);
2512 }
2513
2514 if (agent->var_t_total) {
2515 struct sample smp;
2516
2517 memset(&smp, 0, sizeof(smp));
2518 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2519 smp.data.u.sint = ctx->stats.t_total;
2520 smp.data.type = SMP_T_SINT;
2521
2522 spoe_set_var(ctx, "txn", agent->var_t_total,
2523 strlen(agent->var_t_total), &smp);
2524 }
2525}
2526
2527static void
2528spoe_handle_processing_error(struct stream *s, struct spoe_agent *agent,
2529 struct spoe_context *ctx, int dir)
2530{
2531 if (agent->eps_max > 0)
2532 update_freq_ctr(&agent->rt[tid].err_per_sec, 1);
2533
2534 if (agent->var_on_error) {
2535 struct sample smp;
2536
2537 memset(&smp, 0, sizeof(smp));
2538 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2539 smp.data.u.sint = ctx->status_code;
2540 smp.data.type = SMP_T_BOOL;
2541
2542 spoe_set_var(ctx, "txn", agent->var_on_error,
2543 strlen(agent->var_on_error), &smp);
2544 }
2545
2546 ctx->state = ((agent->flags & SPOE_FL_CONT_ON_ERR)
2547 ? SPOE_CTX_ST_READY
2548 : SPOE_CTX_ST_NONE);
2549}
2550
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002551static inline int
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002552spoe_start_processing(struct spoe_agent *agent, struct spoe_context *ctx, int dir)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002553{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002554 /* If a process is already started for this SPOE context, retry
2555 * later. */
2556 if (ctx->flags & SPOE_CTX_FL_PROCESS)
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002557 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002558
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002559 agent->rt[tid].processing++;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002560 ctx->stats.tv_start = now;
2561 ctx->stats.tv_request = now;
2562 ctx->stats.t_request = -1;
2563 ctx->stats.t_queue = -1;
2564 ctx->stats.t_waiting = -1;
2565 ctx->stats.t_response = -1;
2566 ctx->stats.t_process = -1;
2567
2568 ctx->status_code = 0;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002569
Christopher Fauleta1cda022016-12-21 08:58:06 +01002570 /* Set the right flag to prevent request and response processing
2571 * in same time. */
2572 ctx->flags |= ((dir == SMP_OPT_DIR_REQ)
2573 ? SPOE_CTX_FL_REQ_PROCESS
2574 : SPOE_CTX_FL_RSP_PROCESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002575 return 1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002576}
2577
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002578static inline void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002579spoe_stop_processing(struct spoe_agent *agent, struct spoe_context *ctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002580{
Christopher Fauletfce747b2018-01-24 15:59:32 +01002581 struct spoe_appctx *sa = ctx->spoe_appctx;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002582
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002583 if (!(ctx->flags & SPOE_CTX_FL_PROCESS))
2584 return;
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002585 _HA_ATOMIC_ADD(&agent->counters.nb_processed, 1);
Christopher Faulet879dca92018-03-23 11:53:24 +01002586 if (sa) {
2587 if (sa->frag_ctx.ctx == ctx) {
2588 sa->frag_ctx.ctx = NULL;
2589 spoe_wakeup_appctx(sa->owner);
2590 }
2591 else
2592 sa->cur_fpa--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002593 }
2594
Christopher Fauleta1cda022016-12-21 08:58:06 +01002595 /* Reset the flag to allow next processing */
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002596 agent->rt[tid].processing--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002597 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002598
2599 /* Reset processing timer */
2600 ctx->process_exp = TICK_ETERNITY;
2601
Christopher Faulet8ef75252017-02-20 22:56:03 +01002602 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002603
Christopher Fauletfce747b2018-01-24 15:59:32 +01002604 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002605 ctx->frag_ctx.curmsg = NULL;
2606 ctx->frag_ctx.curarg = NULL;
2607 ctx->frag_ctx.curoff = 0;
2608 ctx->frag_ctx.flags = 0;
2609
Christopher Fauleta1cda022016-12-21 08:58:06 +01002610 if (!LIST_ISEMPTY(&ctx->list)) {
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002611 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS)
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002612 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002613 else
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002614 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002615
Christopher Fauleta1cda022016-12-21 08:58:06 +01002616 LIST_DEL(&ctx->list);
2617 LIST_INIT(&ctx->list);
2618 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002619}
2620
Christopher Faulet58d03682017-09-21 16:57:24 +02002621/* Process a list of SPOE messages. First, this functions will process messages
2622 * and send them to an agent in a NOTIFY frame. Then, it will wait a ACK frame
2623 * to process corresponding actions. During all the processing, it returns 0
2624 * and it returns 1 when the processing is finished. If an error occurred, -1
2625 * is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002626static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002627spoe_process_messages(struct stream *s, struct spoe_context *ctx,
2628 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002629{
Christopher Fauletf7a30922016-11-10 15:04:51 +01002630 struct spoe_config *conf = FLT_CONF(ctx->filter);
2631 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002632 int ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002633
2634 if (ctx->state == SPOE_CTX_ST_ERROR)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002635 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002636
2637 if (tick_is_expired(ctx->process_exp, now_ms) && ctx->state != SPOE_CTX_ST_DONE) {
2638 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002639 " - failed to process messages: timeout\n",
Christopher Fauletf7a30922016-11-10 15:04:51 +01002640 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002641 agent->id, __FUNCTION__, s);
Christopher Fauletb067b062017-01-04 16:39:11 +01002642 ctx->status_code = SPOE_CTX_ERR_TOUT;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002643 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002644 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002645
2646 if (ctx->state == SPOE_CTX_ST_READY) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002647 if (agent->eps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002648 if (!freq_ctr_remain(&agent->rt[tid].err_per_sec, agent->eps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002649 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002650 " - skip processing of messages: max EPS reached\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002651 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002652 agent->id, __FUNCTION__, s);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002653 goto skip;
2654 }
2655 }
2656
Christopher Fauletf7a30922016-11-10 15:04:51 +01002657 if (!tick_isset(ctx->process_exp)) {
2658 ctx->process_exp = tick_add_ifset(now_ms, agent->timeout.processing);
2659 s->task->expire = tick_first((tick_is_expired(s->task->expire, now_ms) ? 0 : s->task->expire),
2660 ctx->process_exp);
2661 }
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002662 ret = spoe_start_processing(agent, ctx, dir);
Christopher Fauletb067b062017-01-04 16:39:11 +01002663 if (!ret)
2664 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002665
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002666 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002667 /* fall through */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002668 }
2669
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002670 if (ctx->state == SPOE_CTX_ST_ENCODING_MSGS) {
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002671 if (!tv_iszero(&ctx->stats.tv_request))
2672 ctx->stats.tv_request = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002673 if (!spoe_acquire_buffer(&ctx->buffer, &ctx->buffer_wait))
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002674 goto out;
Christopher Faulet58d03682017-09-21 16:57:24 +02002675 ret = spoe_encode_messages(s, ctx, messages, dir, type);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002676 if (ret < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002677 goto end;
Christopher Faulet57583e42017-09-04 15:41:09 +02002678 if (!ret)
2679 goto skip;
Christopher Faulet333694d2018-01-12 10:45:47 +01002680 if (spoe_queue_context(ctx) < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002681 goto end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002682 ctx->state = SPOE_CTX_ST_SENDING_MSGS;
2683 }
2684
2685 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS) {
Christopher Fauletfce747b2018-01-24 15:59:32 +01002686 if (ctx->spoe_appctx)
2687 spoe_wakeup_appctx(ctx->spoe_appctx->owner);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002688 ret = 0;
2689 goto out;
2690 }
2691
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002692 if (ctx->state == SPOE_CTX_ST_WAITING_ACK) {
2693 ret = 0;
2694 goto out;
2695 }
2696
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002697 if (ctx->state == SPOE_CTX_ST_DONE) {
Christopher Faulet58d03682017-09-21 16:57:24 +02002698 spoe_process_actions(s, ctx, dir);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002699 ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002700 ctx->frame_id++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002701 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002702 spoe_update_stat_time(&ctx->stats.tv_response, &ctx->stats.t_response);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002703 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002704 }
2705
2706 out:
2707 return ret;
2708
Christopher Fauleta1cda022016-12-21 08:58:06 +01002709 skip:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002710 tv_zero(&ctx->stats.tv_start);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002711 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002712 spoe_stop_processing(agent, ctx);
2713 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002714
Christopher Fauleta1cda022016-12-21 08:58:06 +01002715 end:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002716 spoe_update_stats(s, agent, ctx, dir);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002717 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002718 if (ctx->status_code) {
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002719 _HA_ATOMIC_ADD(&agent->counters.nb_errors, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002720 spoe_handle_processing_error(s, agent, ctx, dir);
2721 ret = 1;
2722 }
Christopher Faulet58d03682017-09-21 16:57:24 +02002723 return ret;
2724}
2725
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002726/* Process a SPOE group, ie the list of messages attached to the group <grp>.
2727 * See spoe_process_message for details. */
2728static int
2729spoe_process_group(struct stream *s, struct spoe_context *ctx,
2730 struct spoe_group *group, int dir)
2731{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002732 struct spoe_config *conf = FLT_CONF(ctx->filter);
2733 struct spoe_agent *agent = conf->agent;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002734 int ret;
2735
2736 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2737 " - ctx-state=%s - Process messages for group=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002738 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002739 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2740 group->id);
2741
2742 if (LIST_ISEMPTY(&group->messages))
2743 return 1;
2744
2745 ret = spoe_process_messages(s, ctx, &group->messages, dir, SPOE_MSGS_BY_GROUP);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002746 if (ret && ctx->stats.t_process != -1) {
2747 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002748 " - <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 +01002749 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002750 __FUNCTION__, s, group->id, s->uniq_id, ctx->status_code,
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002751 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002752 ctx->stats.t_response, ctx->stats.t_process,
2753 agent->counters.idles, agent->counters.applets,
2754 agent->counters.nb_sending, agent->counters.nb_waiting,
2755 agent->counters.nb_errors, agent->counters.nb_processed,
2756 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2757 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2758 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2759 "SPOE: [%s] <GROUP:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2760 agent->id, group->id, s->uniq_id, ctx->status_code,
2761 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2762 ctx->stats.t_response, ctx->stats.t_process,
2763 agent->counters.idles, agent->counters.applets,
2764 agent->counters.nb_sending, agent->counters.nb_waiting,
2765 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002766 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002767 return ret;
2768}
2769
Christopher Faulet58d03682017-09-21 16:57:24 +02002770/* Process a SPOE event, ie the list of messages attached to the event <ev>.
2771 * See spoe_process_message for details. */
2772static int
2773spoe_process_event(struct stream *s, struct spoe_context *ctx,
2774 enum spoe_event ev)
2775{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002776 struct spoe_config *conf = FLT_CONF(ctx->filter);
2777 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002778 int dir, ret;
2779
2780 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002781 " - ctx-state=%s - Process messages for event=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002782 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet58d03682017-09-21 16:57:24 +02002783 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2784 spoe_event_str[ev]);
2785
2786 dir = ((ev < SPOE_EV_ON_SERVER_SESS) ? SMP_OPT_DIR_REQ : SMP_OPT_DIR_RES);
2787
2788 if (LIST_ISEMPTY(&(ctx->events[ev])))
2789 return 1;
2790
2791 ret = spoe_process_messages(s, ctx, &(ctx->events[ev]), dir, SPOE_MSGS_BY_EVENT);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002792 if (ret && ctx->stats.t_process != -1) {
2793 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002794 " - <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 +01002795 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2796 __FUNCTION__, s, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2797 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002798 ctx->stats.t_response, ctx->stats.t_process,
2799 agent->counters.idles, agent->counters.applets,
2800 agent->counters.nb_sending, agent->counters.nb_waiting,
2801 agent->counters.nb_errors, agent->counters.nb_processed,
2802 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2803 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2804 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2805 "SPOE: [%s] <EVENT:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2806 agent->id, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2807 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2808 ctx->stats.t_response, ctx->stats.t_process,
2809 agent->counters.idles, agent->counters.applets,
2810 agent->counters.nb_sending, agent->counters.nb_waiting,
2811 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002812 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002813 return ret;
2814}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002815
2816/***************************************************************************
2817 * Functions that create/destroy SPOE contexts
2818 **************************************************************************/
Christopher Fauleta1cda022016-12-21 08:58:06 +01002819static int
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002820spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002821{
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002822 if (buf->size)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002823 return 1;
2824
Christopher Faulet4596fb72017-01-11 14:05:19 +01002825 if (!LIST_ISEMPTY(&buffer_wait->list)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002826 HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Faulet4596fb72017-01-11 14:05:19 +01002827 LIST_DEL(&buffer_wait->list);
2828 LIST_INIT(&buffer_wait->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002829 HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002830 }
2831
Christopher Faulet4596fb72017-01-11 14:05:19 +01002832 if (b_alloc_margin(buf, global.tune.reserved_bufs))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002833 return 1;
2834
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_ADDQ(&buffer_wq, &buffer_wait->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002837 HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002838 return 0;
2839}
2840
2841static void
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002842spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002843{
Christopher Faulet4596fb72017-01-11 14:05:19 +01002844 if (!LIST_ISEMPTY(&buffer_wait->list)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002845 HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Faulet4596fb72017-01-11 14:05:19 +01002846 LIST_DEL(&buffer_wait->list);
2847 LIST_INIT(&buffer_wait->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002848 HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002849 }
2850
2851 /* Release the buffer if needed */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002852 if (buf->size) {
Christopher Faulet4596fb72017-01-11 14:05:19 +01002853 b_free(buf);
Olivier Houchard673867c2018-05-25 16:58:52 +02002854 offer_buffers(buffer_wait->target, tasks_run_queue);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002855 }
2856}
2857
Christopher Faulet4596fb72017-01-11 14:05:19 +01002858static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002859spoe_wakeup_context(struct spoe_context *ctx)
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002860{
2861 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
2862 return 1;
2863}
2864
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002865static struct spoe_context *
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002866spoe_create_context(struct stream *s, struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002867{
2868 struct spoe_config *conf = FLT_CONF(filter);
2869 struct spoe_context *ctx;
2870
Willy Tarreaubafbe012017-11-24 17:34:44 +01002871 ctx = pool_alloc_dirty(pool_head_spoe_ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002872 if (ctx == NULL) {
2873 return NULL;
2874 }
2875 memset(ctx, 0, sizeof(*ctx));
Christopher Fauletb067b062017-01-04 16:39:11 +01002876 ctx->filter = filter;
2877 ctx->state = SPOE_CTX_ST_NONE;
2878 ctx->status_code = SPOE_CTX_ERR_NONE;
2879 ctx->flags = 0;
Christopher Faulet11610f32017-09-21 10:23:10 +02002880 ctx->events = conf->agent->events;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02002881 ctx->groups = &conf->agent->groups;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002882 ctx->buffer = BUF_NULL;
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002883 LIST_INIT(&ctx->buffer_wait.list);
2884 ctx->buffer_wait.target = ctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002885 ctx->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_context;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002886 LIST_INIT(&ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002887
Christopher Fauletf7a30922016-11-10 15:04:51 +01002888 ctx->stream_id = 0;
2889 ctx->frame_id = 1;
2890 ctx->process_exp = TICK_ETERNITY;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002891
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002892 tv_zero(&ctx->stats.tv_start);
2893 tv_zero(&ctx->stats.tv_request);
2894 tv_zero(&ctx->stats.tv_queue);
2895 tv_zero(&ctx->stats.tv_wait);
2896 tv_zero(&ctx->stats.tv_response);
2897 ctx->stats.t_request = -1;
2898 ctx->stats.t_queue = -1;
2899 ctx->stats.t_waiting = -1;
2900 ctx->stats.t_response = -1;
2901 ctx->stats.t_process = -1;
2902 ctx->stats.t_total = 0;
2903
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002904 ctx->strm = s;
2905 ctx->state = SPOE_CTX_ST_READY;
2906 filter->ctx = ctx;
2907
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002908 return ctx;
2909}
2910
2911static void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002912spoe_destroy_context(struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002913{
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002914 struct spoe_config *conf = FLT_CONF(filter);
2915 struct spoe_context *ctx = filter->ctx;
2916
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002917 if (!ctx)
2918 return;
2919
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002920 spoe_stop_processing(conf->agent, ctx);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002921 pool_free(pool_head_spoe_ctx, ctx);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002922 filter->ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002923}
2924
2925static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002926spoe_reset_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002927{
2928 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01002929 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002930
2931 tv_zero(&ctx->stats.tv_start);
2932 tv_zero(&ctx->stats.tv_request);
2933 tv_zero(&ctx->stats.tv_queue);
2934 tv_zero(&ctx->stats.tv_wait);
2935 tv_zero(&ctx->stats.tv_response);
2936 ctx->stats.t_request = -1;
2937 ctx->stats.t_queue = -1;
2938 ctx->stats.t_waiting = -1;
2939 ctx->stats.t_response = -1;
2940 ctx->stats.t_process = -1;
2941 ctx->stats.t_total = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002942}
2943
2944
2945/***************************************************************************
2946 * Hooks that manage the filter lifecycle (init/check/deinit)
2947 **************************************************************************/
2948/* Signal handler: Do a soft stop, wakeup SPOE applet */
2949static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002950spoe_sig_stop(struct sig_handler *sh)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002951{
2952 struct proxy *p;
2953
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002954 p = proxies_list;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002955 while (p) {
2956 struct flt_conf *fconf;
2957
2958 list_for_each_entry(fconf, &p->filter_configs, list) {
Christopher Faulet3b386a32017-02-23 10:17:15 +01002959 struct spoe_config *conf;
2960 struct spoe_agent *agent;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002961 struct spoe_appctx *spoe_appctx;
Christopher Faulet24289f22017-09-25 14:48:02 +02002962 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002963
Christopher Faulet3b386a32017-02-23 10:17:15 +01002964 if (fconf->id != spoe_filter_id)
2965 continue;
2966
2967 conf = fconf->conf;
2968 agent = conf->agent;
2969
Christopher Faulet24289f22017-09-25 14:48:02 +02002970 for (i = 0; i < global.nbthread; ++i) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002971 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02002972 list_for_each_entry(spoe_appctx, &agent->rt[i].applets, list)
2973 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002974 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002975 }
2976 }
2977 p = p->next;
2978 }
2979}
2980
2981
2982/* Initialize the SPOE filter. Returns -1 on error, else 0. */
2983static int
2984spoe_init(struct proxy *px, struct flt_conf *fconf)
2985{
2986 struct spoe_config *conf = fconf->conf;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002987
Christopher Faulet7250b8f2018-03-26 17:19:01 +02002988 /* conf->agent_fe was already initialized during the config
2989 * parsing. Finish initialization. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002990 conf->agent_fe.last_change = now.tv_sec;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002991 conf->agent_fe.cap = PR_CAP_FE;
2992 conf->agent_fe.mode = PR_MODE_TCP;
2993 conf->agent_fe.maxconn = 0;
2994 conf->agent_fe.options2 |= PR_O2_INDEPSTR;
2995 conf->agent_fe.conn_retries = CONN_RETRIES;
2996 conf->agent_fe.accept = frontend_accept;
2997 conf->agent_fe.srv = NULL;
2998 conf->agent_fe.timeout.client = TICK_ETERNITY;
2999 conf->agent_fe.default_target = &spoe_applet.obj_type;
3000 conf->agent_fe.fe_req_ana = AN_REQ_SWITCHING_RULES;
3001
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003002 if (!sighandler_registered) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003003 signal_register_fct(0, spoe_sig_stop, 0);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003004 sighandler_registered = 1;
3005 }
3006
Christopher Faulet00292352019-01-09 15:05:10 +01003007 fconf->flags |= FLT_CFG_FL_HTX;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003008 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003009}
3010
3011/* Free ressources allocated by the SPOE filter. */
3012static void
3013spoe_deinit(struct proxy *px, struct flt_conf *fconf)
3014{
3015 struct spoe_config *conf = fconf->conf;
3016
3017 if (conf) {
3018 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003019
Christopher Faulet8ef75252017-02-20 22:56:03 +01003020 spoe_release_agent(agent);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003021 free(conf->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003022 free(conf);
3023 }
3024 fconf->conf = NULL;
3025}
3026
3027/* Check configuration of a SPOE filter for a specified proxy.
3028 * Return 1 on error, else 0. */
3029static int
3030spoe_check(struct proxy *px, struct flt_conf *fconf)
3031{
Christopher Faulet7ee86672017-09-19 11:08:28 +02003032 struct flt_conf *f;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003033 struct spoe_config *conf = fconf->conf;
3034 struct proxy *target;
Willy Tarreaub0769b22019-02-07 13:40:33 +01003035 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003036
Christopher Faulet7ee86672017-09-19 11:08:28 +02003037 /* Check all SPOE filters for proxy <px> to be sure all SPOE agent names
3038 * are uniq */
3039 list_for_each_entry(f, &px->filter_configs, list) {
3040 struct spoe_config *c = f->conf;
3041
3042 /* This is not an SPOE filter */
3043 if (f->id != spoe_filter_id)
3044 continue;
3045 /* This is the current SPOE filter */
3046 if (f == fconf)
3047 continue;
3048
3049 /* Check engine Id. It should be uniq */
3050 if (!strcmp(conf->id, c->id)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003051 ha_alert("Proxy %s : duplicated name for SPOE engine '%s'.\n",
3052 px->id, conf->id);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003053 return 1;
3054 }
3055 }
3056
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003057 target = proxy_be_by_name(conf->agent->b.name);
3058 if (target == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003059 ha_alert("Proxy %s : unknown backend '%s' used by SPOE agent '%s'"
3060 " declared at %s:%d.\n",
3061 px->id, conf->agent->b.name, conf->agent->id,
3062 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003063 return 1;
3064 }
3065 if (target->mode != PR_MODE_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003066 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3067 " at %s:%d does not support HTTP mode.\n",
3068 px->id, target->id, conf->agent->id,
3069 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003070 return 1;
3071 }
3072
Willy Tarreau2bdcfde2019-02-05 13:37:19 +01003073 if (px->bind_proc & ~target->bind_proc) {
3074 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3075 " at %s:%d does not cover all of its processes.\n",
3076 px->id, target->id, conf->agent->id,
3077 conf->agent->conf.file, conf->agent->conf.line);
3078 return 1;
3079 }
3080
Willy Tarreaub0769b22019-02-07 13:40:33 +01003081 /* finish per-thread agent initialization */
3082 if (global.nbthread == 1)
3083 conf->agent->flags |= SPOE_FL_ASYNC;
3084
3085 if ((curagent->rt = calloc(global.nbthread, sizeof(*curagent->rt))) == NULL) {
3086 ha_alert("Proxy %s : out of memory initializing SPOE agent '%s' declared at %s:%d.\n",
3087 px->id, conf->agent->id, conf->agent->conf.file, conf->agent->conf.line);
3088 return 1;
3089 }
3090 for (i = 0; i < global.nbthread; ++i) {
3091 curagent->rt[i].frame_size = curagent->max_frame_size;
3092 curagent->rt[i].processing = 0;
3093 LIST_INIT(&curagent->rt[i].applets);
3094 LIST_INIT(&curagent->rt[i].sending_queue);
3095 LIST_INIT(&curagent->rt[i].waiting_queue);
3096 HA_SPIN_INIT(&curagent->rt[i].lock);
3097 }
3098
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003099 free(conf->agent->b.name);
3100 conf->agent->b.name = NULL;
3101 conf->agent->b.be = target;
3102 return 0;
3103}
3104
3105/**************************************************************************
3106 * Hooks attached to a stream
3107 *************************************************************************/
3108/* Called when a filter instance is created and attach to a stream. It creates
3109 * the context that will be used to process this stream. */
3110static int
3111spoe_start(struct stream *s, struct filter *filter)
3112{
Christopher Faulet72bcc472017-01-04 16:39:41 +01003113 struct spoe_config *conf = FLT_CONF(filter);
3114 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003115 struct spoe_context *ctx;
3116
3117 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
Christopher Faulet72bcc472017-01-04 16:39:41 +01003118 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003119 __FUNCTION__, s);
3120
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003121 if ((ctx = spoe_create_context(s, filter)) == NULL) {
Christopher Faulet72bcc472017-01-04 16:39:41 +01003122 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
3123 " - failed to create SPOE context\n",
3124 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletccbc3fd2017-09-15 11:51:18 +02003125 __FUNCTION__, s);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02003126 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01003127 "SPOE: [%s] failed to create SPOE context\n",
3128 agent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003129 return 0;
3130 }
3131
Christopher Faulet11610f32017-09-21 10:23:10 +02003132 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003133 filter->pre_analyzers |= AN_REQ_INSPECT_FE;
3134
Christopher Faulet11610f32017-09-21 10:23:10 +02003135 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003136 filter->pre_analyzers |= AN_REQ_INSPECT_BE;
3137
Christopher Faulet11610f32017-09-21 10:23:10 +02003138 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003139 filter->pre_analyzers |= AN_RES_INSPECT;
3140
Christopher Faulet11610f32017-09-21 10:23:10 +02003141 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003142 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_FE;
3143
Christopher Faulet11610f32017-09-21 10:23:10 +02003144 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003145 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_BE;
3146
Christopher Faulet11610f32017-09-21 10:23:10 +02003147 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003148 filter->pre_analyzers |= AN_RES_HTTP_PROCESS_FE;
3149
3150 return 1;
3151}
3152
3153/* Called when a filter instance is detached from a stream. It release the
3154 * attached SPOE context. */
3155static void
3156spoe_stop(struct stream *s, struct filter *filter)
3157{
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003158 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
3159 (int)now.tv_sec, (int)now.tv_usec,
3160 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3161 __FUNCTION__, s);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003162 spoe_destroy_context(filter);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003163}
3164
Christopher Fauletf7a30922016-11-10 15:04:51 +01003165
3166/*
3167 * Called when the stream is woken up because of expired timer.
3168 */
3169static void
3170spoe_check_timeouts(struct stream *s, struct filter *filter)
3171{
3172 struct spoe_context *ctx = filter->ctx;
3173
Christopher Fauletac580602018-03-20 16:09:20 +01003174 if (tick_is_expired(ctx->process_exp, now_ms))
Christopher Fauleta73e59b2016-12-09 17:30:18 +01003175 s->pending_events |= TASK_WOKEN_MSG;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003176}
3177
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003178/* Called when we are ready to filter data on a channel */
3179static int
3180spoe_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3181{
3182 struct spoe_context *ctx = filter->ctx;
3183 int ret = 1;
3184
3185 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3186 " - ctx-flags=0x%08x\n",
3187 (int)now.tv_sec, (int)now.tv_usec,
3188 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3189 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3190
Christopher Fauletb067b062017-01-04 16:39:11 +01003191 if (ctx->state == SPOE_CTX_ST_NONE)
3192 goto out;
3193
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003194 if (!(chn->flags & CF_ISRESP)) {
3195 if (filter->pre_analyzers & AN_REQ_INSPECT_FE)
3196 chn->analysers |= AN_REQ_INSPECT_FE;
3197 if (filter->pre_analyzers & AN_REQ_INSPECT_BE)
3198 chn->analysers |= AN_REQ_INSPECT_BE;
3199
3200 if (ctx->flags & SPOE_CTX_FL_CLI_CONNECTED)
3201 goto out;
3202
3203 ctx->stream_id = s->uniq_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01003204 ret = spoe_process_event(s, ctx, SPOE_EV_ON_CLIENT_SESS);
Christopher Fauletb067b062017-01-04 16:39:11 +01003205 if (!ret)
3206 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003207 ctx->flags |= SPOE_CTX_FL_CLI_CONNECTED;
3208 }
3209 else {
3210 if (filter->pre_analyzers & SPOE_EV_ON_TCP_RSP)
3211 chn->analysers |= AN_RES_INSPECT;
3212
3213 if (ctx->flags & SPOE_CTX_FL_SRV_CONNECTED)
3214 goto out;
3215
Christopher Faulet8ef75252017-02-20 22:56:03 +01003216 ret = spoe_process_event(s, ctx, SPOE_EV_ON_SERVER_SESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003217 if (!ret) {
3218 channel_dont_read(chn);
3219 channel_dont_close(chn);
Christopher Fauletb067b062017-01-04 16:39:11 +01003220 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003221 }
Christopher Fauletb067b062017-01-04 16:39:11 +01003222 ctx->flags |= SPOE_CTX_FL_SRV_CONNECTED;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003223 }
3224
3225 out:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003226 return ret;
3227}
3228
3229/* Called before a processing happens on a given channel */
3230static int
3231spoe_chn_pre_analyze(struct stream *s, struct filter *filter,
3232 struct channel *chn, unsigned an_bit)
3233{
3234 struct spoe_context *ctx = filter->ctx;
3235 int ret = 1;
3236
3237 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3238 " - ctx-flags=0x%08x - ana=0x%08x\n",
3239 (int)now.tv_sec, (int)now.tv_usec,
3240 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3241 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
3242 ctx->flags, an_bit);
3243
Christopher Fauletb067b062017-01-04 16:39:11 +01003244 if (ctx->state == SPOE_CTX_ST_NONE)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003245 goto out;
3246
3247 switch (an_bit) {
3248 case AN_REQ_INSPECT_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003249 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003250 break;
3251 case AN_REQ_INSPECT_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003252 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003253 break;
3254 case AN_RES_INSPECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003255 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003256 break;
3257 case AN_REQ_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003258 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003259 break;
3260 case AN_REQ_HTTP_PROCESS_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003261 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003262 break;
3263 case AN_RES_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003264 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003265 break;
3266 }
3267
3268 out:
Christopher Faulet9cdca972018-02-01 08:45:45 +01003269 if (!ret && (chn->flags & CF_ISRESP)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003270 channel_dont_read(chn);
3271 channel_dont_close(chn);
3272 }
3273 return ret;
3274}
3275
3276/* Called when the filtering on the channel ends. */
3277static int
3278spoe_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3279{
3280 struct spoe_context *ctx = filter->ctx;
3281
3282 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3283 " - ctx-flags=0x%08x\n",
3284 (int)now.tv_sec, (int)now.tv_usec,
3285 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3286 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3287
3288 if (!(ctx->flags & SPOE_CTX_FL_PROCESS)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003289 spoe_reset_context(ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003290 }
3291
3292 return 1;
3293}
3294
3295/********************************************************************
3296 * Functions that manage the filter initialization
3297 ********************************************************************/
3298struct flt_ops spoe_ops = {
3299 /* Manage SPOE filter, called for each filter declaration */
3300 .init = spoe_init,
3301 .deinit = spoe_deinit,
3302 .check = spoe_check,
3303
3304 /* Handle start/stop of SPOE */
Christopher Fauletf7a30922016-11-10 15:04:51 +01003305 .attach = spoe_start,
3306 .detach = spoe_stop,
3307 .check_timeouts = spoe_check_timeouts,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003308
3309 /* Handle channels activity */
3310 .channel_start_analyze = spoe_start_analyze,
3311 .channel_pre_analyze = spoe_chn_pre_analyze,
3312 .channel_end_analyze = spoe_end_analyze,
3313};
3314
3315
3316static int
3317cfg_parse_spoe_agent(const char *file, int linenum, char **args, int kwm)
3318{
3319 const char *err;
3320 int i, err_code = 0;
3321
3322 if ((cfg_scope == NULL && curengine != NULL) ||
3323 (cfg_scope != NULL && curengine == NULL) ||
Christopher Faulete1405e52017-09-19 10:35:35 +02003324 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003325 goto out;
3326
3327 if (!strcmp(args[0], "spoe-agent")) { /* new spoe-agent section */
3328 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003329 ha_alert("parsing [%s:%d] : missing name for spoe-agent section.\n",
3330 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003331 err_code |= ERR_ALERT | ERR_ABORT;
3332 goto out;
3333 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003334 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3335 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003336 goto out;
3337 }
3338
3339 err = invalid_char(args[1]);
3340 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003341 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3342 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003343 err_code |= ERR_ALERT | ERR_ABORT;
3344 goto out;
3345 }
3346
3347 if (curagent != NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003348 ha_alert("parsing [%s:%d] : another spoe-agent section previously defined.\n",
3349 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003350 err_code |= ERR_ALERT | ERR_ABORT;
3351 goto out;
3352 }
3353 if ((curagent = calloc(1, sizeof(*curagent))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003354 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003355 err_code |= ERR_ALERT | ERR_ABORT;
3356 goto out;
3357 }
3358
3359 curagent->id = strdup(args[1]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003360
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003361 curagent->conf.file = strdup(file);
3362 curagent->conf.line = linenum;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003363
3364 curagent->timeout.hello = TICK_ETERNITY;
3365 curagent->timeout.idle = TICK_ETERNITY;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003366 curagent->timeout.processing = TICK_ETERNITY;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003367
3368 curagent->engine_id = NULL;
3369 curagent->var_pfx = NULL;
3370 curagent->var_on_error = NULL;
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003371 curagent->var_t_process = NULL;
3372 curagent->var_t_total = NULL;
Christopher Faulet24289f22017-09-25 14:48:02 +02003373 curagent->flags = (SPOE_FL_PIPELINING | SPOE_FL_SND_FRAGMENTATION);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003374 curagent->cps_max = 0;
3375 curagent->eps_max = 0;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01003376 curagent->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01003377 curagent->max_fpa = 20;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003378
3379 for (i = 0; i < SPOE_EV_EVENTS; ++i)
Christopher Faulet11610f32017-09-21 10:23:10 +02003380 LIST_INIT(&curagent->events[i]);
3381 LIST_INIT(&curagent->groups);
3382 LIST_INIT(&curagent->messages);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003383 }
3384 else if (!strcmp(args[0], "use-backend")) {
3385 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003386 ha_alert("parsing [%s:%d] : '%s' expects a backend name.\n",
3387 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003388 err_code |= ERR_ALERT | ERR_FATAL;
3389 goto out;
3390 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003391 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003392 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003393 free(curagent->b.name);
3394 curagent->b.name = strdup(args[1]);
3395 }
3396 else if (!strcmp(args[0], "messages")) {
3397 int cur_arg = 1;
3398 while (*args[cur_arg]) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003399 struct spoe_placeholder *ph = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003400
Christopher Faulet11610f32017-09-21 10:23:10 +02003401 list_for_each_entry(ph, &curmphs, list) {
3402 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003403 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3404 file, linenum, args[cur_arg]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003405 err_code |= ERR_ALERT | ERR_FATAL;
3406 goto out;
3407 }
3408 }
3409
Christopher Faulet11610f32017-09-21 10:23:10 +02003410 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003411 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003412 err_code |= ERR_ALERT | ERR_ABORT;
3413 goto out;
3414 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003415 ph->id = strdup(args[cur_arg]);
3416 LIST_ADDQ(&curmphs, &ph->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003417 cur_arg++;
3418 }
3419 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003420 else if (!strcmp(args[0], "groups")) {
3421 int cur_arg = 1;
3422 while (*args[cur_arg]) {
3423 struct spoe_placeholder *ph = NULL;
3424
3425 list_for_each_entry(ph, &curgphs, list) {
3426 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003427 ha_alert("parsing [%s:%d]: spoe-group '%s' already used.\n",
3428 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003429 err_code |= ERR_ALERT | ERR_FATAL;
3430 goto out;
3431 }
3432 }
3433
3434 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003435 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003436 err_code |= ERR_ALERT | ERR_ABORT;
3437 goto out;
3438 }
3439 ph->id = strdup(args[cur_arg]);
3440 LIST_ADDQ(&curgphs, &ph->list);
3441 cur_arg++;
3442 }
3443 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003444 else if (!strcmp(args[0], "timeout")) {
3445 unsigned int *tv = NULL;
3446 const char *res;
3447 unsigned timeout;
3448
3449 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003450 ha_alert("parsing [%s:%d] : 'timeout' expects 'hello', 'idle' and 'processing'.\n",
3451 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003452 err_code |= ERR_ALERT | ERR_FATAL;
3453 goto out;
3454 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003455 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3456 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003457 if (!strcmp(args[1], "hello"))
3458 tv = &curagent->timeout.hello;
3459 else if (!strcmp(args[1], "idle"))
3460 tv = &curagent->timeout.idle;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003461 else if (!strcmp(args[1], "processing"))
3462 tv = &curagent->timeout.processing;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003463 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003464 ha_alert("parsing [%s:%d] : 'timeout' supports 'hello', 'idle' or 'processing' (got %s).\n",
3465 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003466 err_code |= ERR_ALERT | ERR_FATAL;
3467 goto out;
3468 }
3469 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003470 ha_alert("parsing [%s:%d] : 'timeout %s' expects an integer value (in milliseconds).\n",
3471 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003472 err_code |= ERR_ALERT | ERR_FATAL;
3473 goto out;
3474 }
3475 res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
3476 if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003477 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'timeout %s'.\n",
3478 file, linenum, *res, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003479 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003480 goto out;
3481 }
3482 *tv = MS_TO_TICKS(timeout);
3483 }
3484 else if (!strcmp(args[0], "option")) {
3485 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003486 ha_alert("parsing [%s:%d]: '%s' expects an option name.\n",
3487 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003488 err_code |= ERR_ALERT | ERR_FATAL;
3489 goto out;
3490 }
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003491
Christopher Faulet305c6072017-02-23 16:17:53 +01003492 if (!strcmp(args[1], "pipelining")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003493 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003494 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003495 if (kwm == 1)
3496 curagent->flags &= ~SPOE_FL_PIPELINING;
3497 else
3498 curagent->flags |= SPOE_FL_PIPELINING;
3499 goto out;
3500 }
3501 else if (!strcmp(args[1], "async")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003502 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003503 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003504 if (kwm == 1)
3505 curagent->flags &= ~SPOE_FL_ASYNC;
Christopher Faulet24289f22017-09-25 14:48:02 +02003506 else {
3507 if (global.nbthread == 1)
3508 curagent->flags |= SPOE_FL_ASYNC;
3509 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003510 ha_warning("parsing [%s:%d] Async option is not supported with threads.\n",
3511 file, linenum);
Christopher Faulet24289f22017-09-25 14:48:02 +02003512 err_code |= ERR_WARN;
3513 }
3514 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003515 goto out;
3516 }
Christopher Fauletcecd8522017-02-24 22:11:21 +01003517 else if (!strcmp(args[1], "send-frag-payload")) {
3518 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3519 goto out;
3520 if (kwm == 1)
3521 curagent->flags &= ~SPOE_FL_SND_FRAGMENTATION;
3522 else
3523 curagent->flags |= SPOE_FL_SND_FRAGMENTATION;
3524 goto out;
3525 }
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003526 else if (!strcmp(args[1], "dontlog-normal")) {
3527 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3528 goto out;
3529 if (kwm == 1)
3530 curpxopts2 &= ~PR_O2_NOLOGNORM;
3531 else
3532 curpxopts2 |= PR_O2_NOLOGNORM;
Christopher Faulet799f5182018-04-26 11:36:34 +02003533 goto out;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003534 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003535
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003536 /* Following options does not support negation */
3537 if (kwm == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003538 ha_alert("parsing [%s:%d]: negation is not supported for option '%s'.\n",
3539 file, linenum, args[1]);
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003540 err_code |= ERR_ALERT | ERR_FATAL;
3541 goto out;
3542 }
3543
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003544 if (!strcmp(args[1], "var-prefix")) {
3545 char *tmp;
3546
3547 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003548 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3549 file, linenum, args[0],
3550 args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003551 err_code |= ERR_ALERT | ERR_FATAL;
3552 goto out;
3553 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003554 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3555 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003556 tmp = args[2];
3557 while (*tmp) {
3558 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003559 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003560 file, linenum, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003561 err_code |= ERR_ALERT | ERR_FATAL;
3562 goto out;
3563 }
3564 tmp++;
3565 }
3566 curagent->var_pfx = strdup(args[2]);
3567 }
Etienne Carriereaec89892017-12-14 09:36:40 +00003568 else if (!strcmp(args[1], "force-set-var")) {
3569 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3570 goto out;
3571 curagent->flags |= SPOE_FL_FORCE_SET_VAR;
3572 }
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003573 else if (!strcmp(args[1], "continue-on-error")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003574 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003575 goto out;
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003576 curagent->flags |= SPOE_FL_CONT_ON_ERR;
3577 }
Christopher Faulet985532d2016-11-16 15:36:19 +01003578 else if (!strcmp(args[1], "set-on-error")) {
3579 char *tmp;
3580
3581 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003582 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3583 file, linenum, args[0],
3584 args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003585 err_code |= ERR_ALERT | ERR_FATAL;
3586 goto out;
3587 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003588 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3589 goto out;
Christopher Faulet985532d2016-11-16 15:36:19 +01003590 tmp = args[2];
3591 while (*tmp) {
3592 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003593 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003594 file, linenum, args[0], args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003595 err_code |= ERR_ALERT | ERR_FATAL;
3596 goto out;
3597 }
3598 tmp++;
3599 }
3600 curagent->var_on_error = strdup(args[2]);
3601 }
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003602 else if (!strcmp(args[1], "set-process-time")) {
3603 char *tmp;
3604
3605 if (!*args[2]) {
3606 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3607 file, linenum, args[0],
3608 args[1]);
3609 err_code |= ERR_ALERT | ERR_FATAL;
3610 goto out;
3611 }
3612 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3613 goto out;
3614 tmp = args[2];
3615 while (*tmp) {
3616 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003617 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003618 file, linenum, args[0], args[1]);
3619 err_code |= ERR_ALERT | ERR_FATAL;
3620 goto out;
3621 }
3622 tmp++;
3623 }
3624 curagent->var_t_process = strdup(args[2]);
3625 }
3626 else if (!strcmp(args[1], "set-total-time")) {
3627 char *tmp;
3628
3629 if (!*args[2]) {
3630 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3631 file, linenum, args[0],
3632 args[1]);
3633 err_code |= ERR_ALERT | ERR_FATAL;
3634 goto out;
3635 }
3636 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3637 goto out;
3638 tmp = args[2];
3639 while (*tmp) {
3640 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003641 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003642 file, linenum, args[0], args[1]);
3643 err_code |= ERR_ALERT | ERR_FATAL;
3644 goto out;
3645 }
3646 tmp++;
3647 }
3648 curagent->var_t_total = strdup(args[2]);
3649 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003650 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003651 ha_alert("parsing [%s:%d]: option '%s' is not supported.\n",
3652 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003653 err_code |= ERR_ALERT | ERR_FATAL;
3654 goto out;
3655 }
Christopher Faulet48026722016-11-16 15:01:12 +01003656 }
3657 else if (!strcmp(args[0], "maxconnrate")) {
3658 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003659 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3660 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003661 err_code |= ERR_ALERT | ERR_FATAL;
3662 goto out;
3663 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003664 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003665 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003666 curagent->cps_max = atol(args[1]);
3667 }
3668 else if (!strcmp(args[0], "maxerrrate")) {
3669 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003670 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3671 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003672 err_code |= ERR_ALERT | ERR_FATAL;
3673 goto out;
3674 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003675 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003676 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003677 curagent->eps_max = atol(args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003678 }
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003679 else if (!strcmp(args[0], "max-frame-size")) {
3680 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003681 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3682 file, linenum, args[0]);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003683 err_code |= ERR_ALERT | ERR_FATAL;
3684 goto out;
3685 }
3686 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3687 goto out;
3688 curagent->max_frame_size = atol(args[1]);
3689 if (curagent->max_frame_size < MIN_FRAME_SIZE ||
3690 curagent->max_frame_size > MAX_FRAME_SIZE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003691 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument in the range [%d, %d].\n",
3692 file, linenum, args[0], MIN_FRAME_SIZE, MAX_FRAME_SIZE);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003693 err_code |= ERR_ALERT | ERR_FATAL;
3694 goto out;
3695 }
3696 }
Christopher Faulete8ade382018-01-25 15:32:22 +01003697 else if (!strcmp(args[0], "max-waiting-frames")) {
3698 if (!*args[1]) {
3699 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3700 file, linenum, args[0]);
3701 err_code |= ERR_ALERT | ERR_FATAL;
3702 goto out;
3703 }
3704 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3705 goto out;
3706 curagent->max_fpa = atol(args[1]);
3707 if (curagent->max_fpa < 1) {
3708 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument.\n",
3709 file, linenum, args[0]);
3710 err_code |= ERR_ALERT | ERR_FATAL;
3711 goto out;
3712 }
3713 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003714 else if (!strcmp(args[0], "register-var-names")) {
3715 int cur_arg;
3716
3717 if (!*args[1]) {
3718 ha_alert("parsing [%s:%d] : '%s' expects one or more variable names.\n",
3719 file, linenum, args[0]);
3720 err_code |= ERR_ALERT | ERR_FATAL;
3721 goto out;
3722 }
3723 cur_arg = 1;
3724 while (*args[cur_arg]) {
3725 struct spoe_var_placeholder *vph;
3726
3727 if ((vph = calloc(1, sizeof(*vph))) == NULL) {
3728 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3729 err_code |= ERR_ALERT | ERR_ABORT;
3730 goto out;
3731 }
3732 if ((vph->name = strdup(args[cur_arg])) == NULL) {
3733 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3734 err_code |= ERR_ALERT | ERR_ABORT;
3735 goto out;
3736 }
3737 LIST_ADDQ(&curvars, &vph->list);
3738 cur_arg++;
3739 }
3740 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003741 else if (!strcmp(args[0], "log")) {
3742 char *errmsg = NULL;
3743
3744 if (!parse_logsrv(args, &curlogsrvs, (kwm == 1), &errmsg)) {
3745 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
3746 err_code |= ERR_ALERT | ERR_FATAL;
3747 goto out;
3748 }
3749 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003750 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003751 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-agent section.\n",
3752 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003753 err_code |= ERR_ALERT | ERR_FATAL;
3754 goto out;
3755 }
3756 out:
3757 return err_code;
3758}
Christopher Faulet11610f32017-09-21 10:23:10 +02003759static int
3760cfg_parse_spoe_group(const char *file, int linenum, char **args, int kwm)
3761{
3762 struct spoe_group *grp;
3763 const char *err;
3764 int err_code = 0;
3765
3766 if ((cfg_scope == NULL && curengine != NULL) ||
3767 (cfg_scope != NULL && curengine == NULL) ||
3768 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
3769 goto out;
3770
3771 if (!strcmp(args[0], "spoe-group")) { /* new spoe-group section */
3772 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003773 ha_alert("parsing [%s:%d] : missing name for spoe-group section.\n",
3774 file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003775 err_code |= ERR_ALERT | ERR_ABORT;
3776 goto out;
3777 }
3778 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3779 err_code |= ERR_ABORT;
3780 goto out;
3781 }
3782
3783 err = invalid_char(args[1]);
3784 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003785 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3786 file, linenum, *err, args[0], args[1]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003787 err_code |= ERR_ALERT | ERR_ABORT;
3788 goto out;
3789 }
3790
3791 list_for_each_entry(grp, &curgrps, list) {
3792 if (!strcmp(grp->id, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003793 ha_alert("parsing [%s:%d]: spoe-group section '%s' has the same"
3794 " name as another one declared at %s:%d.\n",
3795 file, linenum, args[1], grp->conf.file, grp->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02003796 err_code |= ERR_ALERT | ERR_FATAL;
3797 goto out;
3798 }
3799 }
3800
3801 if ((curgrp = calloc(1, sizeof(*curgrp))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003802 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003803 err_code |= ERR_ALERT | ERR_ABORT;
3804 goto out;
3805 }
3806
3807 curgrp->id = strdup(args[1]);
3808 curgrp->conf.file = strdup(file);
3809 curgrp->conf.line = linenum;
3810 LIST_INIT(&curgrp->phs);
3811 LIST_INIT(&curgrp->messages);
3812 LIST_ADDQ(&curgrps, &curgrp->list);
3813 }
3814 else if (!strcmp(args[0], "messages")) {
3815 int cur_arg = 1;
3816 while (*args[cur_arg]) {
3817 struct spoe_placeholder *ph = NULL;
3818
3819 list_for_each_entry(ph, &curgrp->phs, list) {
3820 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003821 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3822 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003823 err_code |= ERR_ALERT | ERR_FATAL;
3824 goto out;
3825 }
3826 }
3827
3828 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003829 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003830 err_code |= ERR_ALERT | ERR_ABORT;
3831 goto out;
3832 }
3833 ph->id = strdup(args[cur_arg]);
3834 LIST_ADDQ(&curgrp->phs, &ph->list);
3835 cur_arg++;
3836 }
3837 }
3838 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003839 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-group section.\n",
3840 file, linenum, args[0]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003841 err_code |= ERR_ALERT | ERR_FATAL;
3842 goto out;
3843 }
3844 out:
3845 return err_code;
3846}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003847
3848static int
3849cfg_parse_spoe_message(const char *file, int linenum, char **args, int kwm)
3850{
3851 struct spoe_message *msg;
3852 struct spoe_arg *arg;
3853 const char *err;
3854 char *errmsg = NULL;
3855 int err_code = 0;
3856
3857 if ((cfg_scope == NULL && curengine != NULL) ||
3858 (cfg_scope != NULL && curengine == NULL) ||
Christopher Faulete1405e52017-09-19 10:35:35 +02003859 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003860 goto out;
3861
3862 if (!strcmp(args[0], "spoe-message")) { /* new spoe-message section */
3863 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003864 ha_alert("parsing [%s:%d] : missing name for spoe-message section.\n",
3865 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003866 err_code |= ERR_ALERT | ERR_ABORT;
3867 goto out;
3868 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003869 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3870 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003871 goto out;
3872 }
3873
3874 err = invalid_char(args[1]);
3875 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003876 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3877 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003878 err_code |= ERR_ALERT | ERR_ABORT;
3879 goto out;
3880 }
3881
3882 list_for_each_entry(msg, &curmsgs, list) {
3883 if (!strcmp(msg->id, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003884 ha_alert("parsing [%s:%d]: spoe-message section '%s' has the same"
3885 " name as another one declared at %s:%d.\n",
3886 file, linenum, args[1], msg->conf.file, msg->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003887 err_code |= ERR_ALERT | ERR_FATAL;
3888 goto out;
3889 }
3890 }
3891
3892 if ((curmsg = calloc(1, sizeof(*curmsg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003893 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003894 err_code |= ERR_ALERT | ERR_ABORT;
3895 goto out;
3896 }
3897
3898 curmsg->id = strdup(args[1]);
3899 curmsg->id_len = strlen(curmsg->id);
3900 curmsg->event = SPOE_EV_NONE;
3901 curmsg->conf.file = strdup(file);
3902 curmsg->conf.line = linenum;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003903 curmsg->nargs = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003904 LIST_INIT(&curmsg->args);
Christopher Faulet57583e42017-09-04 15:41:09 +02003905 LIST_INIT(&curmsg->acls);
Christopher Faulet11610f32017-09-21 10:23:10 +02003906 LIST_INIT(&curmsg->by_evt);
3907 LIST_INIT(&curmsg->by_grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003908 LIST_ADDQ(&curmsgs, &curmsg->list);
3909 }
3910 else if (!strcmp(args[0], "args")) {
3911 int cur_arg = 1;
3912
3913 curproxy->conf.args.ctx = ARGC_SPOE;
3914 curproxy->conf.args.file = file;
3915 curproxy->conf.args.line = linenum;
3916 while (*args[cur_arg]) {
3917 char *delim = strchr(args[cur_arg], '=');
3918 int idx = 0;
3919
3920 if ((arg = calloc(1, sizeof(*arg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003921 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003922 err_code |= ERR_ALERT | ERR_ABORT;
3923 goto out;
3924 }
3925
3926 if (!delim) {
3927 arg->name = NULL;
3928 arg->name_len = 0;
3929 delim = args[cur_arg];
3930 }
3931 else {
3932 arg->name = my_strndup(args[cur_arg], delim - args[cur_arg]);
3933 arg->name_len = delim - args[cur_arg];
3934 delim++;
3935 }
Christopher Fauletb0b42382017-02-23 22:41:09 +01003936 arg->expr = sample_parse_expr((char*[]){delim, NULL},
3937 &idx, file, linenum, &errmsg,
3938 &curproxy->conf.args);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003939 if (arg->expr == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003940 ha_alert("parsing [%s:%d] : '%s': %s.\n", file, linenum, args[0], errmsg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003941 err_code |= ERR_ALERT | ERR_FATAL;
3942 free(arg->name);
3943 free(arg);
3944 goto out;
3945 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003946 curmsg->nargs++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003947 LIST_ADDQ(&curmsg->args, &arg->list);
3948 cur_arg++;
3949 }
3950 curproxy->conf.args.file = NULL;
3951 curproxy->conf.args.line = 0;
3952 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003953 else if (!strcmp(args[0], "acl")) {
3954 err = invalid_char(args[1]);
3955 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003956 ha_alert("parsing [%s:%d] : character '%c' is not permitted in acl name '%s'.\n",
3957 file, linenum, *err, args[1]);
Christopher Faulet57583e42017-09-04 15:41:09 +02003958 err_code |= ERR_ALERT | ERR_FATAL;
3959 goto out;
3960 }
3961 if (parse_acl((const char **)args + 1, &curmsg->acls, &errmsg, &curproxy->conf.args, file, linenum) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003962 ha_alert("parsing [%s:%d] : error detected while parsing ACL '%s' : %s.\n",
3963 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02003964 err_code |= ERR_ALERT | ERR_FATAL;
3965 goto out;
3966 }
3967 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003968 else if (!strcmp(args[0], "event")) {
3969 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003970 ha_alert("parsing [%s:%d] : missing event name.\n", file, linenum);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003971 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003972 goto out;
3973 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003974 /* if (alertif_too_many_args(1, file, linenum, args, &err_code)) */
3975 /* goto out; */
Christopher Fauletecc537a2017-02-23 22:52:39 +01003976
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003977 if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_CLIENT_SESS]))
3978 curmsg->event = SPOE_EV_ON_CLIENT_SESS;
3979 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_SERVER_SESS]))
3980 curmsg->event = SPOE_EV_ON_SERVER_SESS;
3981
3982 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_FE]))
3983 curmsg->event = SPOE_EV_ON_TCP_REQ_FE;
3984 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_BE]))
3985 curmsg->event = SPOE_EV_ON_TCP_REQ_BE;
3986 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_RSP]))
3987 curmsg->event = SPOE_EV_ON_TCP_RSP;
3988
3989 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_FE]))
3990 curmsg->event = SPOE_EV_ON_HTTP_REQ_FE;
3991 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_BE]))
3992 curmsg->event = SPOE_EV_ON_HTTP_REQ_BE;
3993 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_RSP]))
3994 curmsg->event = SPOE_EV_ON_HTTP_RSP;
3995 else {
Joseph Herlantf1da69d2018-11-15 13:49:02 -08003996 ha_alert("parsing [%s:%d] : unknown event '%s'.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003997 file, linenum, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003998 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003999 goto out;
4000 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004001
4002 if (strcmp(args[2], "if") == 0 || strcmp(args[2], "unless") == 0) {
4003 struct acl_cond *cond;
4004
4005 cond = build_acl_cond(file, linenum, &curmsg->acls,
4006 curproxy, (const char **)args+2,
4007 &errmsg);
4008 if (cond == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004009 ha_alert("parsing [%s:%d] : error detected while "
4010 "parsing an 'event %s' condition : %s.\n",
4011 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02004012 err_code |= ERR_ALERT | ERR_FATAL;
4013 goto out;
4014 }
4015 curmsg->cond = cond;
4016 }
4017 else if (*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004018 ha_alert("parsing [%s:%d]: 'event %s' expects either 'if' "
4019 "or 'unless' followed by a condition but found '%s'.\n",
4020 file, linenum, args[1], args[2]);
Christopher Faulet57583e42017-09-04 15:41:09 +02004021 err_code |= ERR_ALERT | ERR_FATAL;
4022 goto out;
4023 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004024 }
4025 else if (!*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004026 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-message section.\n",
4027 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004028 err_code |= ERR_ALERT | ERR_FATAL;
4029 goto out;
4030 }
4031 out:
4032 free(errmsg);
4033 return err_code;
4034}
4035
4036/* Return -1 on error, else 0 */
4037static int
4038parse_spoe_flt(char **args, int *cur_arg, struct proxy *px,
4039 struct flt_conf *fconf, char **err, void *private)
4040{
4041 struct list backup_sections;
4042 struct spoe_config *conf;
4043 struct spoe_message *msg, *msgback;
Christopher Faulet11610f32017-09-21 10:23:10 +02004044 struct spoe_group *grp, *grpback;
4045 struct spoe_placeholder *ph, *phback;
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004046 struct spoe_var_placeholder *vph, *vphback;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004047 struct logsrv *logsrv, *logsrvback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004048 char *file = NULL, *engine = NULL;
4049 int ret, pos = *cur_arg + 1;
4050
Christopher Faulet84c844e2018-03-23 14:37:14 +01004051 LIST_INIT(&curmsgs);
4052 LIST_INIT(&curgrps);
4053 LIST_INIT(&curmphs);
4054 LIST_INIT(&curgphs);
4055 LIST_INIT(&curvars);
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004056 LIST_INIT(&curlogsrvs);
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004057 curpxopts = 0;
4058 curpxopts2 = 0;
Christopher Faulet84c844e2018-03-23 14:37:14 +01004059
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004060 conf = calloc(1, sizeof(*conf));
4061 if (conf == NULL) {
4062 memprintf(err, "%s: out of memory", args[*cur_arg]);
4063 goto error;
4064 }
4065 conf->proxy = px;
4066
4067 while (*args[pos]) {
4068 if (!strcmp(args[pos], "config")) {
4069 if (!*args[pos+1]) {
4070 memprintf(err, "'%s' : '%s' option without value",
4071 args[*cur_arg], args[pos]);
4072 goto error;
4073 }
4074 file = args[pos+1];
4075 pos += 2;
4076 }
4077 else if (!strcmp(args[pos], "engine")) {
4078 if (!*args[pos+1]) {
4079 memprintf(err, "'%s' : '%s' option without value",
4080 args[*cur_arg], args[pos]);
4081 goto error;
4082 }
4083 engine = args[pos+1];
4084 pos += 2;
4085 }
4086 else {
4087 memprintf(err, "unknown keyword '%s'", args[pos]);
4088 goto error;
4089 }
4090 }
4091 if (file == NULL) {
4092 memprintf(err, "'%s' : missing config file", args[*cur_arg]);
4093 goto error;
4094 }
4095
4096 /* backup sections and register SPOE sections */
4097 LIST_INIT(&backup_sections);
4098 cfg_backup_sections(&backup_sections);
Christopher Faulet11610f32017-09-21 10:23:10 +02004099 cfg_register_section("spoe-agent", cfg_parse_spoe_agent, NULL);
4100 cfg_register_section("spoe-group", cfg_parse_spoe_group, NULL);
William Lallemandd2ff56d2017-10-16 11:06:50 +02004101 cfg_register_section("spoe-message", cfg_parse_spoe_message, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004102
4103 /* Parse SPOE filter configuration file */
4104 curengine = engine;
4105 curproxy = px;
4106 curagent = NULL;
4107 curmsg = NULL;
4108 ret = readcfgfile(file);
4109 curproxy = NULL;
4110
4111 /* unregister SPOE sections and restore previous sections */
4112 cfg_unregister_sections();
4113 cfg_restore_sections(&backup_sections);
4114
4115 if (ret == -1) {
4116 memprintf(err, "Could not open configuration file %s : %s",
4117 file, strerror(errno));
4118 goto error;
4119 }
4120 if (ret & (ERR_ABORT|ERR_FATAL)) {
4121 memprintf(err, "Error(s) found in configuration file %s", file);
4122 goto error;
4123 }
4124
4125 /* Check SPOE agent */
4126 if (curagent == NULL) {
4127 memprintf(err, "No SPOE agent found in file %s", file);
4128 goto error;
4129 }
4130 if (curagent->b.name == NULL) {
4131 memprintf(err, "No backend declared for SPOE agent '%s' declared at %s:%d",
4132 curagent->id, curagent->conf.file, curagent->conf.line);
4133 goto error;
4134 }
Christopher Fauletf7a30922016-11-10 15:04:51 +01004135 if (curagent->timeout.hello == TICK_ETERNITY ||
4136 curagent->timeout.idle == TICK_ETERNITY ||
Christopher Fauletf7a30922016-11-10 15:04:51 +01004137 curagent->timeout.processing == TICK_ETERNITY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004138 ha_warning("Proxy '%s': missing timeouts for SPOE agent '%s' declare at %s:%d.\n"
4139 " | While not properly invalid, you will certainly encounter various problems\n"
4140 " | with such a configuration. To fix this, please ensure that all following\n"
4141 " | timeouts are set to a non-zero value: 'hello', 'idle', 'processing'.\n",
4142 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004143 }
4144 if (curagent->var_pfx == NULL) {
4145 char *tmp = curagent->id;
4146
4147 while (*tmp) {
4148 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
4149 memprintf(err, "Invalid variable prefix '%s' for SPOE agent '%s' declared at %s:%d. "
4150 "Use 'option var-prefix' to set it. Only [a-zA-Z0-9_.] chars are supported.\n",
4151 curagent->id, curagent->id, curagent->conf.file, curagent->conf.line);
4152 goto error;
4153 }
4154 tmp++;
4155 }
4156 curagent->var_pfx = strdup(curagent->id);
4157 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01004158 if (curagent->engine_id == NULL)
4159 curagent->engine_id = generate_pseudo_uuid();
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004160
Christopher Fauletb7426d12018-03-21 14:12:17 +01004161 if (curagent->var_on_error) {
4162 struct arg arg;
4163
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004164 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Fauletb7426d12018-03-21 14:12:17 +01004165 curagent->var_pfx, curagent->var_on_error);
4166
4167 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004168 arg.data.str.area = trash.area;
4169 arg.data.str.data = trash.data;
Christopher Fauletb7426d12018-03-21 14:12:17 +01004170 if (!vars_check_arg(&arg, err)) {
4171 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4172 curagent->id, curagent->var_pfx, curagent->var_on_error, *err);
4173 goto error;
4174 }
4175 }
4176
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004177 if (curagent->var_t_process) {
4178 struct arg arg;
4179
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004180 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004181 curagent->var_pfx, curagent->var_t_process);
4182
4183 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004184 arg.data.str.area = trash.area;
4185 arg.data.str.data = trash.data;
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004186 if (!vars_check_arg(&arg, err)) {
4187 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4188 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4189 goto error;
4190 }
4191 }
4192
4193 if (curagent->var_t_total) {
4194 struct arg arg;
4195
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004196 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004197 curagent->var_pfx, curagent->var_t_total);
4198
4199 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004200 arg.data.str.area = trash.area;
4201 arg.data.str.data = trash.data;
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004202 if (!vars_check_arg(&arg, err)) {
4203 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4204 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4205 goto error;
4206 }
4207 }
4208
Christopher Faulet11610f32017-09-21 10:23:10 +02004209 if (LIST_ISEMPTY(&curmphs) && LIST_ISEMPTY(&curgphs)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004210 ha_warning("Proxy '%s': No message/group used by SPOE agent '%s' declared at %s:%d.\n",
4211 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004212 goto finish;
4213 }
4214
Christopher Faulet11610f32017-09-21 10:23:10 +02004215 /* Replace placeholders by the corresponding messages for the SPOE
4216 * agent */
4217 list_for_each_entry(ph, &curmphs, list) {
4218 list_for_each_entry(msg, &curmsgs, list) {
Christopher Fauleta21b0642017-01-09 16:56:23 +01004219 struct spoe_arg *arg;
4220 unsigned int where;
4221
Christopher Faulet11610f32017-09-21 10:23:10 +02004222 if (!strcmp(msg->id, ph->id)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004223 if ((px->cap & (PR_CAP_FE|PR_CAP_BE)) == (PR_CAP_FE|PR_CAP_BE)) {
4224 if (msg->event == SPOE_EV_ON_TCP_REQ_BE)
4225 msg->event = SPOE_EV_ON_TCP_REQ_FE;
4226 if (msg->event == SPOE_EV_ON_HTTP_REQ_BE)
4227 msg->event = SPOE_EV_ON_HTTP_REQ_FE;
4228 }
4229 if (!(px->cap & PR_CAP_FE) && (msg->event == SPOE_EV_ON_CLIENT_SESS ||
4230 msg->event == SPOE_EV_ON_TCP_REQ_FE ||
4231 msg->event == SPOE_EV_ON_HTTP_REQ_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004232 ha_warning("Proxy '%s': frontend event used on a backend proxy at %s:%d.\n",
4233 px->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004234 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004235 }
4236 if (msg->event == SPOE_EV_NONE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004237 ha_warning("Proxy '%s': Ignore SPOE message '%s' without event at %s:%d.\n",
4238 px->id, msg->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004239 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004240 }
Christopher Fauleta21b0642017-01-09 16:56:23 +01004241
4242 where = 0;
4243 switch (msg->event) {
4244 case SPOE_EV_ON_CLIENT_SESS:
4245 where |= SMP_VAL_FE_CON_ACC;
4246 break;
4247
4248 case SPOE_EV_ON_TCP_REQ_FE:
4249 where |= SMP_VAL_FE_REQ_CNT;
4250 break;
4251
4252 case SPOE_EV_ON_HTTP_REQ_FE:
4253 where |= SMP_VAL_FE_HRQ_HDR;
4254 break;
4255
4256 case SPOE_EV_ON_TCP_REQ_BE:
4257 if (px->cap & PR_CAP_FE)
4258 where |= SMP_VAL_FE_REQ_CNT;
4259 if (px->cap & PR_CAP_BE)
4260 where |= SMP_VAL_BE_REQ_CNT;
4261 break;
4262
4263 case SPOE_EV_ON_HTTP_REQ_BE:
4264 if (px->cap & PR_CAP_FE)
4265 where |= SMP_VAL_FE_HRQ_HDR;
4266 if (px->cap & PR_CAP_BE)
4267 where |= SMP_VAL_BE_HRQ_HDR;
4268 break;
4269
4270 case SPOE_EV_ON_SERVER_SESS:
4271 where |= SMP_VAL_BE_SRV_CON;
4272 break;
4273
4274 case SPOE_EV_ON_TCP_RSP:
4275 if (px->cap & PR_CAP_FE)
4276 where |= SMP_VAL_FE_RES_CNT;
4277 if (px->cap & PR_CAP_BE)
4278 where |= SMP_VAL_BE_RES_CNT;
4279 break;
4280
4281 case SPOE_EV_ON_HTTP_RSP:
4282 if (px->cap & PR_CAP_FE)
4283 where |= SMP_VAL_FE_HRS_HDR;
4284 if (px->cap & PR_CAP_BE)
4285 where |= SMP_VAL_BE_HRS_HDR;
4286 break;
4287
4288 default:
4289 break;
4290 }
4291
4292 list_for_each_entry(arg, &msg->args, list) {
4293 if (!(arg->expr->fetch->val & where)) {
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004294 memprintf(err, "Ignore SPOE message '%s' at %s:%d: "
Christopher Fauleta21b0642017-01-09 16:56:23 +01004295 "some args extract information from '%s', "
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004296 "none of which is available here ('%s')",
4297 msg->id, msg->conf.file, msg->conf.line,
Christopher Fauleta21b0642017-01-09 16:56:23 +01004298 sample_ckp_names(arg->expr->fetch->use),
4299 sample_ckp_names(where));
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004300 goto error;
Christopher Fauleta21b0642017-01-09 16:56:23 +01004301 }
4302 }
4303
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004304 msg->agent = curagent;
Christopher Faulet11610f32017-09-21 10:23:10 +02004305 LIST_ADDQ(&curagent->events[msg->event], &msg->by_evt);
4306 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004307 }
4308 }
4309 memprintf(err, "SPOE agent '%s' try to use undefined SPOE message '%s' at %s:%d",
Christopher Faulet11610f32017-09-21 10:23:10 +02004310 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004311 goto error;
Christopher Faulet11610f32017-09-21 10:23:10 +02004312 next_mph:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004313 continue;
4314 }
4315
Christopher Faulet11610f32017-09-21 10:23:10 +02004316 /* Replace placeholders by the corresponding groups for the SPOE
4317 * agent */
4318 list_for_each_entry(ph, &curgphs, list) {
4319 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4320 if (!strcmp(grp->id, ph->id)) {
4321 grp->agent = curagent;
4322 LIST_DEL(&grp->list);
4323 LIST_ADDQ(&curagent->groups, &grp->list);
4324 goto next_aph;
4325 }
4326 }
4327 memprintf(err, "SPOE agent '%s' try to use undefined SPOE group '%s' at %s:%d",
4328 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
4329 goto error;
4330 next_aph:
4331 continue;
4332 }
4333
4334 /* Replace placeholders by the corresponding message for each SPOE
4335 * group of the SPOE agent */
4336 list_for_each_entry(grp, &curagent->groups, list) {
4337 list_for_each_entry_safe(ph, phback, &grp->phs, list) {
4338 list_for_each_entry(msg, &curmsgs, list) {
4339 if (!strcmp(msg->id, ph->id)) {
4340 if (msg->group != NULL) {
4341 memprintf(err, "SPOE message '%s' already belongs to "
4342 "the SPOE group '%s' declare at %s:%d",
4343 msg->id, msg->group->id,
4344 msg->group->conf.file,
4345 msg->group->conf.line);
4346 goto error;
4347 }
4348
4349 /* Scope for arguments are not checked for now. We will check
4350 * them only if a rule use the corresponding SPOE group. */
4351 msg->agent = curagent;
4352 msg->group = grp;
4353 LIST_DEL(&ph->list);
4354 LIST_ADDQ(&grp->messages, &msg->by_grp);
4355 goto next_mph_grp;
4356 }
4357 }
4358 memprintf(err, "SPOE group '%s' try to use undefined SPOE message '%s' at %s:%d",
4359 grp->id, ph->id, curagent->conf.file, curagent->conf.line);
4360 goto error;
4361 next_mph_grp:
4362 continue;
4363 }
4364 }
4365
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004366 finish:
Christopher Faulet11610f32017-09-21 10:23:10 +02004367 /* move curmsgs to the agent message list */
4368 curmsgs.n->p = &curagent->messages;
4369 curmsgs.p->n = &curagent->messages;
4370 curagent->messages = curmsgs;
4371 LIST_INIT(&curmsgs);
4372
Christopher Faulet7ee86672017-09-19 11:08:28 +02004373 conf->id = strdup(engine ? engine : curagent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004374 conf->agent = curagent;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004375
4376 /* Start agent's proxy initialization here. It will be finished during
4377 * the filter init. */
4378 memset(&conf->agent_fe, 0, sizeof(conf->agent_fe));
4379 init_new_proxy(&conf->agent_fe);
4380 conf->agent_fe.id = conf->agent->id;
4381 conf->agent_fe.parent = conf->agent;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004382 conf->agent_fe.options |= curpxopts;
4383 conf->agent_fe.options2 |= curpxopts2;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004384
4385 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4386 LIST_DEL(&logsrv->list);
4387 LIST_ADDQ(&conf->agent_fe.logsrvs, &logsrv->list);
4388 }
4389
Christopher Faulet11610f32017-09-21 10:23:10 +02004390 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4391 LIST_DEL(&ph->list);
4392 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004393 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004394 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4395 LIST_DEL(&ph->list);
4396 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004397 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004398 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4399 struct arg arg;
4400
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004401 trash.data = snprintf(trash.area, trash.size, "proc.%s.%s",
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004402 curagent->var_pfx, vph->name);
4403
4404 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004405 arg.data.str.area = trash.area;
4406 arg.data.str.data = trash.data;
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004407 if (!vars_check_arg(&arg, err)) {
4408 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4409 curagent->id, curagent->var_pfx, vph->name, *err);
4410 goto error;
4411 }
4412
4413 LIST_DEL(&vph->list);
4414 free(vph->name);
4415 free(vph);
4416 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004417 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4418 LIST_DEL(&grp->list);
4419 spoe_release_group(grp);
4420 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004421 *cur_arg = pos;
Christopher Faulet3b386a32017-02-23 10:17:15 +01004422 fconf->id = spoe_filter_id;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004423 fconf->ops = &spoe_ops;
4424 fconf->conf = conf;
4425 return 0;
4426
4427 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01004428 spoe_release_agent(curagent);
Christopher Faulet11610f32017-09-21 10:23:10 +02004429 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4430 LIST_DEL(&ph->list);
4431 spoe_release_placeholder(ph);
4432 }
4433 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4434 LIST_DEL(&ph->list);
4435 spoe_release_placeholder(ph);
4436 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004437 list_for_each_entry_safe(vph, vphback, &curvars, list) {
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);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004445 }
4446 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
4447 LIST_DEL(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01004448 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004449 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004450 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4451 LIST_DEL(&logsrv->list);
4452 free(logsrv);
4453 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004454 free(conf);
4455 return -1;
4456}
4457
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004458/* Send message of a SPOE group. This is the action_ptr callback of a rule
4459 * associated to a "send-spoe-group" action.
4460 *
4461 * It returns ACT_RET_CONT is processing is finished without error, it returns
4462 * ACT_RET_YIELD if the action is in progress. Otherwise it returns
4463 * ACT_RET_ERR. */
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004464static enum act_return
4465spoe_send_group(struct act_rule *rule, struct proxy *px,
4466 struct session *sess, struct stream *s, int flags)
4467{
4468 struct filter *filter;
4469 struct spoe_agent *agent = NULL;
4470 struct spoe_group *group = NULL;
4471 struct spoe_context *ctx = NULL;
4472 int ret, dir;
4473
4474 list_for_each_entry(filter, &s->strm_flt.filters, list) {
4475 if (filter->config == rule->arg.act.p[0]) {
4476 agent = rule->arg.act.p[2];
4477 group = rule->arg.act.p[3];
4478 ctx = filter->ctx;
4479 break;
4480 }
4481 }
4482 if (agent == NULL || group == NULL || ctx == NULL)
4483 return ACT_RET_ERR;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004484 if (ctx->state == SPOE_CTX_ST_NONE)
4485 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004486
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004487 switch (rule->from) {
4488 case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break;
4489 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
4490 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
4491 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
4492 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
4493 default:
4494 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4495 " - internal error while execute spoe-send-group\n",
4496 (int)now.tv_sec, (int)now.tv_usec, agent->id,
4497 __FUNCTION__, s);
4498 send_log(px, LOG_ERR, "SPOE: [%s] internal error while execute spoe-send-group\n",
4499 agent->id);
4500 return ACT_RET_CONT;
4501 }
4502
4503 ret = spoe_process_group(s, ctx, group, dir);
4504 if (ret == 1)
4505 return ACT_RET_CONT;
4506 else if (ret == 0) {
4507 if (flags & ACT_FLAG_FINAL) {
4508 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4509 " - failed to process group '%s': interrupted by caller\n",
4510 (int)now.tv_sec, (int)now.tv_usec,
4511 agent->id, __FUNCTION__, s, group->id);
4512 ctx->status_code = SPOE_CTX_ERR_INTERRUPT;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01004513 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02004514 spoe_handle_processing_error(s, agent, ctx, dir);
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004515 return ACT_RET_CONT;
4516 }
4517 return ACT_RET_YIELD;
4518 }
4519 else
4520 return ACT_RET_ERR;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004521}
4522
4523/* Check an "send-spoe-group" action. Here, we'll try to find the real SPOE
4524 * group associated to <rule>. The format of an rule using 'send-spoe-group'
4525 * action should be:
4526 *
4527 * (http|tcp)-(request|response) send-spoe-group <engine-id> <group-id>
4528 *
4529 * So, we'll loop on each configured SPOE filter for the proxy <px> to find the
4530 * SPOE engine matching <engine-id>. And then, we'll try to find the good group
4531 * matching <group-id>. Finally, we'll check all messages referenced by the SPOE
4532 * group.
4533 *
4534 * The function returns 1 in success case, otherwise, it returns 0 and err is
4535 * filled.
4536 */
4537static int
4538check_send_spoe_group(struct act_rule *rule, struct proxy *px, char **err)
4539{
4540 struct flt_conf *fconf;
4541 struct spoe_config *conf;
4542 struct spoe_agent *agent = NULL;
4543 struct spoe_group *group;
4544 struct spoe_message *msg;
4545 char *engine_id = rule->arg.act.p[0];
4546 char *group_id = rule->arg.act.p[1];
4547 unsigned int where = 0;
4548
4549 switch (rule->from) {
4550 case ACT_F_TCP_REQ_SES: where = SMP_VAL_FE_SES_ACC; break;
4551 case ACT_F_TCP_REQ_CNT: where = SMP_VAL_FE_REQ_CNT; break;
4552 case ACT_F_TCP_RES_CNT: where = SMP_VAL_BE_RES_CNT; break;
4553 case ACT_F_HTTP_REQ: where = SMP_VAL_FE_HRQ_HDR; break;
4554 case ACT_F_HTTP_RES: where = SMP_VAL_BE_HRS_HDR; break;
4555 default:
4556 memprintf(err,
4557 "internal error, unexpected rule->from=%d, please report this bug!",
4558 rule->from);
4559 goto error;
4560 }
4561
4562 /* Try to find the SPOE engine by checking all SPOE filters for proxy
4563 * <px> */
4564 list_for_each_entry(fconf, &px->filter_configs, list) {
4565 conf = fconf->conf;
4566
4567 /* This is not an SPOE filter */
4568 if (fconf->id != spoe_filter_id)
4569 continue;
4570
4571 /* This is the good engine */
4572 if (!strcmp(conf->id, engine_id)) {
4573 agent = conf->agent;
4574 break;
4575 }
4576 }
4577 if (agent == NULL) {
4578 memprintf(err, "unable to find SPOE engine '%s' used by the send-spoe-group '%s'",
4579 engine_id, group_id);
4580 goto error;
4581 }
4582
4583 /* Try to find the right group */
4584 list_for_each_entry(group, &agent->groups, list) {
4585 /* This is the good group */
4586 if (!strcmp(group->id, group_id))
4587 break;
4588 }
4589 if (&group->list == &agent->groups) {
4590 memprintf(err, "unable to find SPOE group '%s' into SPOE engine '%s' configuration",
4591 group_id, engine_id);
4592 goto error;
4593 }
4594
4595 /* Ok, we found the group, we need to check messages and their
4596 * arguments */
4597 list_for_each_entry(msg, &group->messages, by_grp) {
4598 struct spoe_arg *arg;
4599
4600 list_for_each_entry(arg, &msg->args, list) {
4601 if (!(arg->expr->fetch->val & where)) {
4602 memprintf(err, "Invalid SPOE message '%s' used by SPOE group '%s' at %s:%d: "
4603 "some args extract information from '%s',"
4604 "none of which is available here ('%s')",
4605 msg->id, group->id, msg->conf.file, msg->conf.line,
4606 sample_ckp_names(arg->expr->fetch->use),
4607 sample_ckp_names(where));
4608 goto error;
4609 }
4610 }
4611 }
4612
4613 free(engine_id);
4614 free(group_id);
4615 rule->arg.act.p[0] = fconf; /* Associate filter config with the rule */
4616 rule->arg.act.p[1] = conf; /* Associate SPOE config with the rule */
4617 rule->arg.act.p[2] = agent; /* Associate SPOE agent with the rule */
4618 rule->arg.act.p[3] = group; /* Associate SPOE group with the rule */
4619 return 1;
4620
4621 error:
4622 free(engine_id);
4623 free(group_id);
4624 return 0;
4625}
4626
4627/* Parse 'send-spoe-group' action following the format:
4628 *
4629 * ... send-spoe-group <engine-id> <group-id>
4630 *
4631 * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error
4632 * message. Otherwise, it returns ACT_RET_PRS_OK and parsing engine and group
4633 * ids are saved and used later, when the rule will be checked.
4634 */
4635static enum act_parse_ret
4636parse_send_spoe_group(const char **args, int *orig_arg, struct proxy *px,
4637 struct act_rule *rule, char **err)
4638{
4639 if (!*args[*orig_arg] || !*args[*orig_arg+1] ||
4640 (*args[*orig_arg+2] && strcmp(args[*orig_arg+2], "if") != 0 && strcmp(args[*orig_arg+2], "unless") != 0)) {
4641 memprintf(err, "expects 2 arguments: <engine-id> <group-id>");
4642 return ACT_RET_PRS_ERR;
4643 }
4644 rule->arg.act.p[0] = strdup(args[*orig_arg]); /* Copy the SPOE engine id */
4645 rule->arg.act.p[1] = strdup(args[*orig_arg+1]); /* Cope the SPOE group id */
4646
4647 (*orig_arg) += 2;
4648
4649 rule->action = ACT_CUSTOM;
4650 rule->action_ptr = spoe_send_group;
4651 rule->check_ptr = check_send_spoe_group;
4652 return ACT_RET_PRS_OK;
4653}
4654
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004655
4656/* Declare the filter parser for "spoe" keyword */
4657static struct flt_kw_list flt_kws = { "SPOE", { }, {
4658 { "spoe", parse_spoe_flt, NULL },
4659 { NULL, NULL, NULL },
4660 }
4661};
4662
Willy Tarreau0108d902018-11-25 19:14:37 +01004663INITCALL1(STG_REGISTER, flt_register_keywords, &flt_kws);
4664
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004665/* Delcate the action parser for "spoe-action" keyword */
4666static struct action_kw_list tcp_req_action_kws = { { }, {
4667 { "send-spoe-group", parse_send_spoe_group },
4668 { /* END */ },
4669 }
4670};
Willy Tarreau0108d902018-11-25 19:14:37 +01004671
4672INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_action_kws);
4673
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004674static struct action_kw_list tcp_res_action_kws = { { }, {
4675 { "send-spoe-group", parse_send_spoe_group },
4676 { /* END */ },
4677 }
4678};
Willy Tarreau0108d902018-11-25 19:14:37 +01004679
4680INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_action_kws);
4681
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004682static struct action_kw_list http_req_action_kws = { { }, {
4683 { "send-spoe-group", parse_send_spoe_group },
4684 { /* END */ },
4685 }
4686};
Willy Tarreau0108d902018-11-25 19:14:37 +01004687
4688INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_action_kws);
4689
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004690static struct action_kw_list http_res_action_kws = { { }, {
4691 { "send-spoe-group", parse_send_spoe_group },
4692 { /* END */ },
4693 }
4694};
4695
Willy Tarreau0108d902018-11-25 19:14:37 +01004696INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_action_kws);