blob: 9288de99fa0c7c9f0109526619793921d0716780 [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>
19#include <common/memory.h>
20#include <common/time.h>
21
22#include <types/arg.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020023#include <types/global.h>
Christopher Faulet1f40b912017-02-17 09:32:19 +010024#include <types/spoe.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020025
26#include <proto/arg.h>
27#include <proto/backend.h>
28#include <proto/filters.h>
Christopher Faulet48026722016-11-16 15:01:12 +010029#include <proto/freq_ctr.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020030#include <proto/frontend.h>
31#include <proto/log.h>
32#include <proto/proto_http.h>
33#include <proto/proxy.h>
34#include <proto/sample.h>
35#include <proto/session.h>
36#include <proto/signal.h>
Christopher Faulet4ff3e572017-02-24 14:31:11 +010037#include <proto/spoe.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020038#include <proto/stream.h>
39#include <proto/stream_interface.h>
40#include <proto/task.h>
41#include <proto/vars.h>
42
43#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
44#define SPOE_PRINTF(x...) fprintf(x)
45#else
46#define SPOE_PRINTF(x...)
47#endif
48
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +010049/* Reserved 4 bytes to the frame size. So a frame and its size can be written
50 * together in a buffer */
51#define MAX_FRAME_SIZE global.tune.bufsize - 4
52
53/* The minimum size for a frame */
54#define MIN_FRAME_SIZE 256
55
Christopher Fauletf51f5fa2017-01-19 10:01:12 +010056/* Reserved for the metadata and the frame type.
57 * So <MAX_FRAME_SIZE> - <FRAME_HDR_SIZE> is the maximum payload size */
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +010058#define FRAME_HDR_SIZE 32
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020059
Christopher Fauletf51f5fa2017-01-19 10:01:12 +010060/* Helper to get SPOE ctx inside an appctx */
Christopher Faulet42bfa462017-01-04 14:14:19 +010061#define SPOE_APPCTX(appctx) ((struct spoe_appctx *)((appctx)->ctx.spoe.ptr))
62
Christopher Faulet3b386a32017-02-23 10:17:15 +010063/* SPOE filter id. Used to identify SPOE filters */
64const char *spoe_filter_id = "SPOE filter";
65
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020066/* Set if the handle on SIGUSR1 is registered */
67static int sighandler_registered = 0;
68
69/* proxy used during the parsing */
70struct proxy *curproxy = NULL;
71
72/* The name of the SPOE engine, used during the parsing */
73char *curengine = NULL;
74
75/* SPOE agent used during the parsing */
76struct spoe_agent *curagent = NULL;
77
78/* SPOE message used during the parsing */
79struct spoe_message *curmsg = NULL;
80
81/* list of SPOE messages and placeholders used during the parsing */
82struct list curmsgs;
83struct list curmps;
84
Christopher Faulet42bfa462017-01-04 14:14:19 +010085/* Pools used to allocate SPOE structs */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020086static struct pool_head *pool2_spoe_ctx = NULL;
Christopher Faulet42bfa462017-01-04 14:14:19 +010087static struct pool_head *pool2_spoe_appctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020088
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020089struct flt_ops spoe_ops;
90
Christopher Faulet8ef75252017-02-20 22:56:03 +010091static int spoe_queue_context(struct spoe_context *ctx);
92static int spoe_acquire_buffer(struct buffer **buf, struct buffer_wait *buffer_wait);
93static void spoe_release_buffer(struct buffer **buf, struct buffer_wait *buffer_wait);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020094
95/********************************************************************
96 * helper functions/globals
97 ********************************************************************/
98static void
Christopher Faulet8ef75252017-02-20 22:56:03 +010099spoe_release_msg_placeholder(struct spoe_msg_placeholder *mp)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200100{
101 if (!mp)
102 return;
103 free(mp->id);
104 free(mp);
105}
106
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200107static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100108spoe_release_message(struct spoe_message *msg)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200109{
110 struct spoe_arg *arg, *back;
111
112 if (!msg)
113 return;
114 free(msg->id);
115 free(msg->conf.file);
116 list_for_each_entry_safe(arg, back, &msg->args, list) {
117 release_sample_expr(arg->expr);
118 free(arg->name);
119 LIST_DEL(&arg->list);
120 free(arg);
121 }
122 free(msg);
123}
124
125static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100126spoe_release_agent(struct spoe_agent *agent)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200127{
128 struct spoe_message *msg, *back;
129 int i;
130
131 if (!agent)
132 return;
133 free(agent->id);
134 free(agent->conf.file);
135 free(agent->var_pfx);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100136 free(agent->engine_id);
Christopher Faulet985532d2016-11-16 15:36:19 +0100137 free(agent->var_on_error);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200138 for (i = 0; i < SPOE_EV_EVENTS; ++i) {
139 list_for_each_entry_safe(msg, back, &agent->messages[i], list) {
140 LIST_DEL(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100141 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200142 }
143 }
144 free(agent);
145}
146
147static const char *spoe_frm_err_reasons[SPOE_FRM_ERRS] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100148 [SPOE_FRM_ERR_NONE] = "normal",
149 [SPOE_FRM_ERR_IO] = "I/O error",
150 [SPOE_FRM_ERR_TOUT] = "a timeout occurred",
151 [SPOE_FRM_ERR_TOO_BIG] = "frame is too big",
152 [SPOE_FRM_ERR_INVALID] = "invalid frame received",
153 [SPOE_FRM_ERR_NO_VSN] = "version value not found",
154 [SPOE_FRM_ERR_NO_FRAME_SIZE] = "max-frame-size value not found",
155 [SPOE_FRM_ERR_NO_CAP] = "capabilities value not found",
156 [SPOE_FRM_ERR_BAD_VSN] = "unsupported version",
157 [SPOE_FRM_ERR_BAD_FRAME_SIZE] = "max-frame-size too big or too small",
158 [SPOE_FRM_ERR_FRAG_NOT_SUPPORTED] = "fragmentation not supported",
159 [SPOE_FRM_ERR_INTERLACED_FRAMES] = "invalid interlaced frames",
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100160 [SPOE_FRM_ERR_FRAMEID_NOTFOUND] = "frame-id not found",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100161 [SPOE_FRM_ERR_RES] = "resource allocation error",
162 [SPOE_FRM_ERR_UNKNOWN] = "an unknown error occurred",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200163};
164
165static const char *spoe_event_str[SPOE_EV_EVENTS] = {
166 [SPOE_EV_ON_CLIENT_SESS] = "on-client-session",
167 [SPOE_EV_ON_TCP_REQ_FE] = "on-frontend-tcp-request",
168 [SPOE_EV_ON_TCP_REQ_BE] = "on-backend-tcp-request",
169 [SPOE_EV_ON_HTTP_REQ_FE] = "on-frontend-http-request",
170 [SPOE_EV_ON_HTTP_REQ_BE] = "on-backend-http-request",
171
172 [SPOE_EV_ON_SERVER_SESS] = "on-server-session",
173 [SPOE_EV_ON_TCP_RSP] = "on-tcp-response",
174 [SPOE_EV_ON_HTTP_RSP] = "on-http-response",
175};
176
177
178#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
179
180static const char *spoe_ctx_state_str[SPOE_CTX_ST_ERROR+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100181 [SPOE_CTX_ST_NONE] = "NONE",
182 [SPOE_CTX_ST_READY] = "READY",
183 [SPOE_CTX_ST_ENCODING_MSGS] = "ENCODING_MSGS",
184 [SPOE_CTX_ST_SENDING_MSGS] = "SENDING_MSGS",
185 [SPOE_CTX_ST_WAITING_ACK] = "WAITING_ACK",
186 [SPOE_CTX_ST_DONE] = "DONE",
187 [SPOE_CTX_ST_ERROR] = "ERROR",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200188};
189
190static const char *spoe_appctx_state_str[SPOE_APPCTX_ST_END+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100191 [SPOE_APPCTX_ST_CONNECT] = "CONNECT",
192 [SPOE_APPCTX_ST_CONNECTING] = "CONNECTING",
193 [SPOE_APPCTX_ST_IDLE] = "IDLE",
194 [SPOE_APPCTX_ST_PROCESSING] = "PROCESSING",
195 [SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY] = "SENDING_FRAG_NOTIFY",
196 [SPOE_APPCTX_ST_WAITING_SYNC_ACK] = "WAITING_SYNC_ACK",
197 [SPOE_APPCTX_ST_DISCONNECT] = "DISCONNECT",
198 [SPOE_APPCTX_ST_DISCONNECTING] = "DISCONNECTING",
199 [SPOE_APPCTX_ST_EXIT] = "EXIT",
200 [SPOE_APPCTX_ST_END] = "END",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200201};
202
203#endif
Christopher Fauleta1cda022016-12-21 08:58:06 +0100204
Christopher Faulet8ef75252017-02-20 22:56:03 +0100205/* Used to generates a unique id for an engine. On success, it returns a
206 * allocated string. So it is the caller's reponsibility to release it. If the
207 * allocation failed, it returns NULL. */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100208static char *
209generate_pseudo_uuid()
210{
211 static int init = 0;
212
213 const char uuid_fmt[] = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
214 const char uuid_chr[] = "0123456789ABCDEF-";
215 char *uuid;
216 int i;
217
218 if ((uuid = calloc(1, sizeof(uuid_fmt))) == NULL)
219 return NULL;
220
221 if (!init) {
222 srand(now_ms);
223 init = 1;
224 }
225
226 for (i = 0; i < sizeof(uuid_fmt)-1; i++) {
227 int r = rand () % 16;
228
229 switch (uuid_fmt[i]) {
230 case 'x' : uuid[i] = uuid_chr[r]; break;
231 case 'y' : uuid[i] = uuid_chr[(r & 0x03) | 0x08]; break;
232 default : uuid[i] = uuid_fmt[i]; break;
233 }
234 }
235 return uuid;
236}
237
Christopher Faulet8ef75252017-02-20 22:56:03 +0100238/* Returns the minimum number of appets alive at a time. This function is used
239 * to know if more applets should be created for an engine. */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100240static inline unsigned int
241min_applets_act(struct spoe_agent *agent)
242{
243 unsigned int nbsrv;
244
Christopher Faulet8ef75252017-02-20 22:56:03 +0100245 /* TODO: Add a config parameter to customize this value. Always 0 for
246 * now */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100247 if (agent->min_applets)
248 return agent->min_applets;
249
Christopher Faulet8ef75252017-02-20 22:56:03 +0100250 /* Get the number of active servers for the backend */
251 nbsrv = (agent->b.be->srv_act
252 ? agent->b.be->srv_act
253 : agent->b.be->srv_bck);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100254 return 2*nbsrv;
255}
256
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200257/********************************************************************
258 * Functions that encode/decode SPOE frames
259 ********************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200260/* Helper to get static string length, excluding the terminating null byte */
261#define SLEN(str) (sizeof(str)-1)
262
263/* Predefined key used in HELLO/DISCONNECT frames */
264#define SUPPORTED_VERSIONS_KEY "supported-versions"
265#define VERSION_KEY "version"
266#define MAX_FRAME_SIZE_KEY "max-frame-size"
267#define CAPABILITIES_KEY "capabilities"
Christopher Fauleta1cda022016-12-21 08:58:06 +0100268#define ENGINE_ID_KEY "engine-id"
Christopher Fauletba7bc162016-11-07 21:07:38 +0100269#define HEALTHCHECK_KEY "healthcheck"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200270#define STATUS_CODE_KEY "status-code"
271#define MSG_KEY "message"
272
273struct spoe_version {
274 char *str;
275 int min;
276 int max;
277};
278
279/* All supported versions */
280static struct spoe_version supported_versions[] = {
281 {"1.0", 1000, 1000},
282 {NULL, 0, 0}
283};
284
285/* Comma-separated list of supported versions */
286#define SUPPORTED_VERSIONS_VAL "1.0"
287
Christopher Faulet8ef75252017-02-20 22:56:03 +0100288/* Convert a string to a SPOE version value. The string must follow the format
289 * "MAJOR.MINOR". It will be concerted into the integer (1000 * MAJOR + MINOR).
290 * If an error occurred, -1 is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200291static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100292spoe_str_to_vsn(const char *str, size_t len)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200293{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100294 const char *p, *end;
295 int maj, min, vsn;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200296
Christopher Faulet8ef75252017-02-20 22:56:03 +0100297 p = str;
298 end = str+len;
299 maj = min = 0;
300 vsn = -1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200301
Christopher Faulet8ef75252017-02-20 22:56:03 +0100302 /* skip leading spaces */
303 while (p < end && isspace(*p))
304 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200305
Christopher Faulet8ef75252017-02-20 22:56:03 +0100306 /* parse Major number, until the '.' */
307 while (*p != '.') {
308 if (p >= end || *p < '0' || *p > '9')
309 goto out;
310 maj *= 10;
311 maj += (*p - '0');
312 p++;
313 }
314
315 /* check Major version */
316 if (!maj)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200317 goto out;
318
Christopher Faulet8ef75252017-02-20 22:56:03 +0100319 p++; /* skip the '.' */
320 if (p >= end || *p < '0' || *p > '9') /* Minor number is missing */
321 goto out;
322
323 /* Parse Minor number */
324 while (p < end) {
325 if (*p < '0' || *p > '9')
326 break;
327 min *= 10;
328 min += (*p - '0');
329 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200330 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100331
332 /* check Minor number */
333 if (min > 999)
334 goto out;
335
336 /* skip trailing spaces */
337 while (p < end && isspace(*p))
338 p++;
339 if (p != end)
340 goto out;
341
342 vsn = maj * 1000 + min;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200343 out:
344 return vsn;
345}
346
Christopher Faulet8ef75252017-02-20 22:56:03 +0100347/* Encode the HELLO frame sent by HAProxy to an agent. It returns the number of
348 * encoded bytes in the frame on success, 0 if an encoding error occured and -1
349 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200350static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100351spoe_prepare_hahello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200352{
Christopher Faulet305c6072017-02-23 16:17:53 +0100353 struct chunk *chk;
Christopher Faulet42bfa462017-01-04 14:14:19 +0100354 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100355 char *p, *end;
356 unsigned int flags = SPOE_FRM_FL_FIN;
357 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200358
Christopher Faulet8ef75252017-02-20 22:56:03 +0100359 p = frame;
360 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200361
Christopher Faulet8ef75252017-02-20 22:56:03 +0100362 /* Set Frame type */
363 *p++ = SPOE_FRM_T_HAPROXY_HELLO;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200364
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100365 /* Set flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100366 memcpy(p, (char *)&flags, 4);
367 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200368
369 /* No stream-id and frame-id for HELLO frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100370 *p++ = 0; *p++ = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200371
372 /* There are 3 mandatory items: "supported-versions", "max-frame-size"
373 * and "capabilities" */
374
375 /* "supported-versions" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100376 sz = SLEN(SUPPORTED_VERSIONS_KEY);
377 if (spoe_encode_buffer(SUPPORTED_VERSIONS_KEY, sz, &p, end) == -1)
378 goto too_big;
379
380 *p++ = SPOE_DATA_T_STR;
381 sz = SLEN(SUPPORTED_VERSIONS_VAL);
382 if (spoe_encode_buffer(SUPPORTED_VERSIONS_VAL, sz, &p, end) == -1)
383 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200384
385 /* "max-fram-size" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100386 sz = SLEN(MAX_FRAME_SIZE_KEY);
387 if (spoe_encode_buffer(MAX_FRAME_SIZE_KEY, sz, &p, end) == -1)
388 goto too_big;
389
390 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200391 if (encode_varint(SPOE_APPCTX(appctx)->max_frame_size, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100392 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200393
394 /* "capabilities" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100395 sz = SLEN(CAPABILITIES_KEY);
396 if (spoe_encode_buffer(CAPABILITIES_KEY, sz, &p, end) == -1)
397 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200398
Christopher Faulet8ef75252017-02-20 22:56:03 +0100399 *p++ = SPOE_DATA_T_STR;
Christopher Faulet305c6072017-02-23 16:17:53 +0100400 chk = get_trash_chunk();
401 if (agent != NULL && (agent->flags & SPOE_FL_PIPELINING)) {
402 memcpy(chk->str, "pipelining", 10);
403 chk->len += 10;
404 }
405 if (agent != NULL && (agent->flags & SPOE_FL_ASYNC)) {
406 if (chk->len) chk->str[chk->len++] = ',';
407 memcpy(chk->str+chk->len, "async", 5);
408 chk->len += 5;
409 }
Christopher Fauletcecd8522017-02-24 22:11:21 +0100410 if (agent != NULL && (agent->flags & SPOE_FL_RCV_FRAGMENTATION)) {
411 if (chk->len) chk->str[chk->len++] = ',';
412 memcpy(chk->str+chk->len, "fragmentation", 13);
413 chk->len += 5;
414 }
Christopher Faulet305c6072017-02-23 16:17:53 +0100415 if (spoe_encode_buffer(chk->str, chk->len, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100416 goto too_big;
417
418 /* (optionnal) "engine-id" K/V item, if present */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100419 if (agent != NULL && agent->engine_id != NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100420 sz = SLEN(ENGINE_ID_KEY);
421 if (spoe_encode_buffer(ENGINE_ID_KEY, sz, &p, end) == -1)
422 goto too_big;
423
424 *p++ = SPOE_DATA_T_STR;
425 sz = strlen(agent->engine_id);
426 if (spoe_encode_buffer(agent->engine_id, sz, &p, end) == -1)
427 goto too_big;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100428 }
429
Christopher Faulet8ef75252017-02-20 22:56:03 +0100430 return (p - frame);
431
432 too_big:
433 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
434 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200435}
436
Christopher Faulet8ef75252017-02-20 22:56:03 +0100437/* Encode DISCONNECT frame sent by HAProxy to an agent. It returns the number of
438 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
439 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200440static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100441spoe_prepare_hadiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200442{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100443 const char *reason;
444 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100445 unsigned int flags = SPOE_FRM_FL_FIN;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100446 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200447
Christopher Faulet8ef75252017-02-20 22:56:03 +0100448 p = frame;
449 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200450
Christopher Faulet8ef75252017-02-20 22:56:03 +0100451 /* Set Frame type */
452 *p++ = SPOE_FRM_T_HAPROXY_DISCON;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200453
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100454 /* Set flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100455 memcpy(p, (char *)&flags, 4);
456 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200457
458 /* No stream-id and frame-id for DISCONNECT frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100459 *p++ = 0; *p++ = 0;
460
461 if (SPOE_APPCTX(appctx)->status_code >= SPOE_FRM_ERRS)
462 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200463
464 /* There are 2 mandatory items: "status-code" and "message" */
465
466 /* "status-code" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100467 sz = SLEN(STATUS_CODE_KEY);
468 if (spoe_encode_buffer(STATUS_CODE_KEY, sz, &p, end) == -1)
469 goto too_big;
470
471 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200472 if (encode_varint(SPOE_APPCTX(appctx)->status_code, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100473 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200474
475 /* "message" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100476 sz = SLEN(MSG_KEY);
477 if (spoe_encode_buffer(MSG_KEY, sz, &p, end) == -1)
478 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200479
Christopher Faulet8ef75252017-02-20 22:56:03 +0100480 /*Get the message corresponding to the status code */
481 reason = spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code];
482
483 *p++ = SPOE_DATA_T_STR;
484 sz = strlen(reason);
485 if (spoe_encode_buffer(reason, sz, &p, end) == -1)
486 goto too_big;
487
488 return (p - frame);
489
490 too_big:
491 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
492 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200493}
494
Christopher Faulet8ef75252017-02-20 22:56:03 +0100495/* Encode the NOTIFY frame sent by HAProxy to an agent. It returns the number of
496 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
497 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200498static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100499spoe_prepare_hanotify_frame(struct appctx *appctx, struct spoe_context *ctx,
Christopher Fauleta1cda022016-12-21 08:58:06 +0100500 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200501{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100502 char *p, *end;
503 unsigned int stream_id, frame_id;
504 unsigned int flags = SPOE_FRM_FL_FIN;
505 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200506
Christopher Faulet8ef75252017-02-20 22:56:03 +0100507 p = frame;
508 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200509
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100510 stream_id = ctx->stream_id;
511 frame_id = ctx->frame_id;
512
513 if (ctx->flags & SPOE_CTX_FL_FRAGMENTED) {
514 /* The fragmentation is not supported by the applet */
515 if (!(SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_FRAGMENTATION)) {
516 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
517 return -1;
518 }
519 flags = ctx->frag_ctx.flags;
520 }
521
522 /* Set Frame type */
523 *p++ = SPOE_FRM_T_HAPROXY_NOTIFY;
524
525 /* Set flags */
526 memcpy(p, (char *)&flags, 4);
527 p += 4;
528
529 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200530 if (encode_varint(stream_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100531 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200532 if (encode_varint(frame_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100533 goto too_big;
534
535 /* Copy encoded messages, if possible */
536 sz = ctx->buffer->i;
537 if (p + sz >= end)
538 goto too_big;
539 memcpy(p, ctx->buffer->p, sz);
540 p += sz;
541
542 return (p - frame);
543
544 too_big:
545 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
546 return 0;
547}
548
549/* Encode next part of a fragmented frame sent by HAProxy to an agent. It
550 * returns the number of encoded bytes in the frame on success, 0 if an encoding
551 * error occurred and -1 if a fatal error occurred. */
552static int
553spoe_prepare_hafrag_frame(struct appctx *appctx, struct spoe_context *ctx,
554 char *frame, size_t size)
555{
556 char *p, *end;
557 unsigned int stream_id, frame_id;
558 unsigned int flags;
559 size_t sz;
560
561 p = frame;
562 end = frame+size;
563
Christopher Faulet8ef75252017-02-20 22:56:03 +0100564 /* <ctx> is null when the stream has aborted the processing of a
565 * fragmented frame. In this case, we must notify the corresponding
566 * agent using ids stored in <frag_ctx>. */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100567 if (ctx == NULL) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100568 flags = (SPOE_FRM_FL_FIN|SPOE_FRM_FL_ABRT);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100569 stream_id = SPOE_APPCTX(appctx)->frag_ctx.cursid;
570 frame_id = SPOE_APPCTX(appctx)->frag_ctx.curfid;
571 }
572 else {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100573 flags = ctx->frag_ctx.flags;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100574 stream_id = ctx->stream_id;
575 frame_id = ctx->frame_id;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100576 }
577
Christopher Faulet8ef75252017-02-20 22:56:03 +0100578 /* Set Frame type */
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100579 *p++ = SPOE_FRM_T_UNSET;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100580
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100581 /* Set flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100582 memcpy(p, (char *)&flags, 4);
583 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200584
585 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200586 if (encode_varint(stream_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100587 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200588 if (encode_varint(frame_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100589 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200590
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100591 if (ctx == NULL)
592 goto end;
593
Christopher Faulet8ef75252017-02-20 22:56:03 +0100594 /* Copy encoded messages, if possible */
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100595 sz = ctx->buffer->i;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100596 if (p + sz >= end)
597 goto too_big;
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100598 memcpy(p, ctx->buffer->p, sz);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100599 p += sz;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100600
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100601 end:
Christopher Faulet8ef75252017-02-20 22:56:03 +0100602 return (p - frame);
603
604 too_big:
605 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
606 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200607}
608
Christopher Faulet8ef75252017-02-20 22:56:03 +0100609/* Decode and process the HELLO frame sent by an agent. It returns the number of
610 * read bytes on success, 0 if a decoding error occurred, and -1 if a fatal
611 * error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200612static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100613spoe_handle_agenthello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200614{
Christopher Faulet305c6072017-02-23 16:17:53 +0100615 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
616 char *p, *end;
617 int vsn, max_frame_size;
618 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100619
620 p = frame;
621 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200622
623 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100624 if (*p++ != SPOE_FRM_T_AGENT_HELLO) {
625 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200626 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100627 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200628
Christopher Faulet8ef75252017-02-20 22:56:03 +0100629 if (size < 7 /* TYPE + METADATA */) {
630 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
631 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200632 }
633
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100634 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100635 memcpy((char *)&flags, p, 4);
636 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200637
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100638 /* Fragmentation is not supported for HELLO frame */
639 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100640 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100641 return -1;
642 }
643
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200644 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100645 if (*p != 0 || *(p+1) != 0) {
646 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
647 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200648 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100649 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200650
651 /* There are 3 mandatory items: "version", "max-frame-size" and
652 * "capabilities" */
653
654 /* Loop on K/V items */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100655 vsn = max_frame_size = flags = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100656 while (p < end) {
657 char *str;
658 size_t sz;
659 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200660
661 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100662 ret = spoe_decode_buffer(&p, end, &str, &sz);
663 if (ret == -1 || !sz) {
664 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
665 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200666 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100667
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200668 /* Check "version" K/V item */
669 if (!memcmp(str, VERSION_KEY, sz)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100670 int i, type = *p++;
671
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200672 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100673 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
674 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
675 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200676 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100677 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
678 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
679 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200680 }
681
Christopher Faulet8ef75252017-02-20 22:56:03 +0100682 vsn = spoe_str_to_vsn(str, sz);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200683 if (vsn == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100684 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200685 return -1;
686 }
687 for (i = 0; supported_versions[i].str != NULL; ++i) {
688 if (vsn >= supported_versions[i].min &&
689 vsn <= supported_versions[i].max)
690 break;
691 }
692 if (supported_versions[i].str == NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100693 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200694 return -1;
695 }
696 }
697 /* Check "max-frame-size" K/V item */
698 else if (!memcmp(str, MAX_FRAME_SIZE_KEY, sz)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100699 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200700
701 /* The value must be integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200702 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
703 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
704 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
705 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100706 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
707 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200708 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200709 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100710 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 if (sz < MIN_FRAME_SIZE ||
714 sz > SPOE_APPCTX(appctx)->max_frame_size) {
715 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200716 return -1;
717 }
718 max_frame_size = sz;
719 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100720 /* Check "capabilities" K/V item */
721 else if (!memcmp(str, CAPABILITIES_KEY, sz)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100722 int type = *p++;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100723
724 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100725 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
726 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
727 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100728 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100729 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
730 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
731 return 0;
732 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100733
Christopher Faulet8ef75252017-02-20 22:56:03 +0100734 while (sz) {
Christopher Fauleta1cda022016-12-21 08:58:06 +0100735 char *delim;
736
737 /* Skip leading spaces */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100738 for (; isspace(*str) && sz; str++, sz--);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100739
Christopher Faulet8ef75252017-02-20 22:56:03 +0100740 if (sz >= 10 && !strncmp(str, "pipelining", 10)) {
741 str += 10; sz -= 10;
742 if (!sz || isspace(*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100743 flags |= SPOE_APPCTX_FL_PIPELINING;
744 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100745 else if (sz >= 5 && !strncmp(str, "async", 5)) {
746 str += 5; sz -= 5;
747 if (!sz || isspace(*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100748 flags |= SPOE_APPCTX_FL_ASYNC;
749 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100750 else if (sz >= 13 && !strncmp(str, "fragmentation", 13)) {
751 str += 13; sz -= 13;
752 if (!sz || isspace(*str) || *str == ',')
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100753 flags |= SPOE_APPCTX_FL_FRAGMENTATION;
754 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100755
Christopher Faulet8ef75252017-02-20 22:56:03 +0100756 /* Get the next comma or break */
757 if (!sz || (delim = memchr(str, ',', sz)) == NULL)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100758 break;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100759 delim++;
760 sz -= (delim - str);
761 str = delim;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100762 }
763 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200764 else {
765 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100766 if (spoe_skip_data(&p, end) == -1) {
767 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
768 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200769 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200770 }
771 }
772
773 /* Final checks */
774 if (!vsn) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100775 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200776 return -1;
777 }
778 if (!max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100779 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200780 return -1;
781 }
Christopher Faulet305c6072017-02-23 16:17:53 +0100782 if ((flags & SPOE_APPCTX_FL_PIPELINING) && !(agent->flags & SPOE_FL_PIPELINING))
783 flags &= ~SPOE_APPCTX_FL_PIPELINING;
784 if ((flags & SPOE_APPCTX_FL_ASYNC) && !(agent->flags & SPOE_FL_ASYNC))
785 flags &= ~SPOE_APPCTX_FL_ASYNC;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200786
Christopher Faulet42bfa462017-01-04 14:14:19 +0100787 SPOE_APPCTX(appctx)->version = (unsigned int)vsn;
788 SPOE_APPCTX(appctx)->max_frame_size = (unsigned int)max_frame_size;
789 SPOE_APPCTX(appctx)->flags |= flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100790
791 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200792}
793
794/* Decode DISCONNECT frame sent by an agent. It returns the number of by read
795 * bytes on success, 0 if the frame can be ignored and -1 if an error
796 * occurred. */
797static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100798spoe_handle_agentdiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200799{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100800 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100801 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100802
803 p = frame;
804 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200805
806 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100807 if (*p++ != SPOE_FRM_T_AGENT_DISCON) {
808 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200809 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100810 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200811
Christopher Faulet8ef75252017-02-20 22:56:03 +0100812 if (size < 7 /* TYPE + METADATA */) {
813 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
814 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200815 }
816
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100817 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100818 memcpy((char *)&flags, p, 4);
819 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200820
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100821 /* Fragmentation is not supported for DISCONNECT frame */
822 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100823 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100824 return -1;
825 }
826
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200827 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100828 if (*p != 0 || *(p+1) != 0) {
829 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
830 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200831 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100832 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200833
834 /* There are 2 mandatory items: "status-code" and "message" */
835
836 /* Loop on K/V items */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100837 while (p < end) {
838 char *str;
839 size_t sz;
840 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200841
842 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100843 ret = spoe_decode_buffer(&p, end, &str, &sz);
844 if (ret == -1 || !sz) {
845 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
846 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200847 }
848
849 /* Check "status-code" K/V item */
850 if (!memcmp(str, STATUS_CODE_KEY, sz)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100851 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200852
853 /* The value must be an integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200854 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
855 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
856 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
857 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100858 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
859 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200860 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200861 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100862 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
863 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200864 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100865 SPOE_APPCTX(appctx)->status_code = sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200866 }
867
868 /* Check "message" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100869 else if (!memcmp(str, MSG_KEY, sz)) {
870 int type = *p++;
871
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200872 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100873 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
874 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
875 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200876 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100877 ret = spoe_decode_buffer(&p, end, &str, &sz);
878 if (ret == -1 || sz > 255) {
879 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
880 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200881 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100882#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
883 SPOE_APPCTX(appctx)->reason = str;
884 SPOE_APPCTX(appctx)->rlen = sz;
885#endif
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200886 }
887 else {
888 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100889 if (spoe_skip_data(&p, end) == -1) {
890 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
891 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200892 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200893 }
894 }
895
Christopher Faulet8ef75252017-02-20 22:56:03 +0100896 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200897}
898
899
Christopher Fauleta1cda022016-12-21 08:58:06 +0100900/* Decode ACK frame sent by an agent. It returns the number of read bytes on
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200901 * success, 0 if the frame can be ignored and -1 if an error occurred. */
902static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100903spoe_handle_agentack_frame(struct appctx *appctx, struct spoe_context **ctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100904 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200905{
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100906 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100907 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100908 uint64_t stream_id, frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100909 int len;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100910 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100911
912 p = frame;
913 end = frame + size;
914 *ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200915
916 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100917 if (*p++ != SPOE_FRM_T_AGENT_ACK) {
918 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200919 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100920 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200921
Christopher Faulet8ef75252017-02-20 22:56:03 +0100922 if (size < 7 /* TYPE + METADATA */) {
923 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
924 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200925 }
926
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100927 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100928 memcpy((char *)&flags, p, 4);
929 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200930
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100931 /* Fragmentation is not supported for now */
932 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100933 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100934 return -1;
935 }
936
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200937 /* Get the stream-id and the frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200938 if (decode_varint(&p, end, &stream_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100939 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100940 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100941 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200942 if (decode_varint(&p, end, &frame_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100943 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200944 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100945 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100946
Christopher Faulet8ef75252017-02-20 22:56:03 +0100947 /* Try to find the corresponding SPOE context */
Christopher Faulet42bfa462017-01-04 14:14:19 +0100948 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100949 list_for_each_entry((*ctx), &agent->waiting_queue, list) {
950 if ((*ctx)->stream_id == (unsigned int)stream_id &&
951 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100952 goto found;
953 }
954 }
955 else {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100956 list_for_each_entry((*ctx), &SPOE_APPCTX(appctx)->waiting_queue, list) {
957 if ((*ctx)->stream_id == (unsigned int)stream_id &&
Christopher Faulet8ef75252017-02-20 22:56:03 +0100958 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100959 goto found;
960 }
961 }
962
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100963 if (SPOE_APPCTX(appctx)->frag_ctx.ctx &&
964 SPOE_APPCTX(appctx)->frag_ctx.cursid == (unsigned int)stream_id &&
965 SPOE_APPCTX(appctx)->frag_ctx.curfid == (unsigned int)frame_id) {
966
967 /* ABRT bit is set for an unfinished fragmented frame */
968 if (flags & SPOE_FRM_FL_ABRT) {
969 *ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
970 (*ctx)->frag_ctx.spoe_appctx = NULL;
971 (*ctx)->state = SPOE_CTX_ST_ERROR;
972 (*ctx)->status_code = SPOE_CTX_ERR_FRAG_FRAME_ABRT;
973 /* Ignore the payload */
974 goto end;
975 }
976 /* TODO: Handle more flags for fragmented frames: RESUME, FINISH... */
977 /* For now, we ignore the ack */
978 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
979 return 0;
980 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100981
Christopher Fauleta1cda022016-12-21 08:58:06 +0100982 /* No Stream found, ignore the frame */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100983 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
984 " - Ignore ACK frame"
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100985 " - stream-id=%u - frame-id=%u\n",
986 (int)now.tv_sec, (int)now.tv_usec, agent->id,
987 __FUNCTION__, appctx,
988 (unsigned int)stream_id, (unsigned int)frame_id);
989
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100990 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAMEID_NOTFOUND;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100991 return 0;
992
993 found:
Christopher Faulet8ef75252017-02-20 22:56:03 +0100994 if (!spoe_acquire_buffer(&SPOE_APPCTX(appctx)->buffer,
995 &SPOE_APPCTX(appctx)->buffer_wait)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100996 *ctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100997 return 1; /* Retry later */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100998 }
Christopher Faulet4596fb72017-01-11 14:05:19 +0100999
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001000 /* Copy encoded actions */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001001 len = (end - p);
1002 memcpy(SPOE_APPCTX(appctx)->buffer->p, p, len);
1003 SPOE_APPCTX(appctx)->buffer->i = len;
1004 p += len;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001005
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001006 /* Transfer the buffer ownership to the SPOE context */
1007 (*ctx)->buffer = SPOE_APPCTX(appctx)->buffer;
1008 SPOE_APPCTX(appctx)->buffer = &buf_empty;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001009
Christopher Faulet8ef75252017-02-20 22:56:03 +01001010 (*ctx)->state = SPOE_CTX_ST_DONE;
1011
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001012 end:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001013 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001014 " - ACK frame received"
1015 " - ctx=%p - stream-id=%u - frame-id=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001016 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001017 __FUNCTION__, appctx, *ctx, (*ctx)->stream_id,
1018 (*ctx)->frame_id, flags);
1019 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001020}
1021
Christopher Fauletba7bc162016-11-07 21:07:38 +01001022/* This function is used in cfgparse.c and declared in proto/checks.h. It
1023 * prepare the request to send to agents during a healthcheck. It returns 0 on
1024 * success and -1 if an error occurred. */
1025int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001026spoe_prepare_healthcheck_request(char **req, int *len)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001027{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001028 struct appctx appctx;
1029 struct spoe_appctx spoe_appctx;
1030 char *frame, *end, buf[MAX_FRAME_SIZE+4];
1031 size_t sz;
1032 int ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001033
Christopher Faulet42bfa462017-01-04 14:14:19 +01001034 memset(&appctx, 0, sizeof(appctx));
1035 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001036 memset(buf, 0, sizeof(buf));
Christopher Faulet42bfa462017-01-04 14:14:19 +01001037
1038 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001039 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001040
Christopher Faulet8ef75252017-02-20 22:56:03 +01001041 frame = buf+4; /* Reserved the 4 first bytes for the frame size */
1042 end = frame + MAX_FRAME_SIZE;
1043
1044 ret = spoe_prepare_hahello_frame(&appctx, frame, MAX_FRAME_SIZE);
1045 if (ret <= 0)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001046 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001047 frame += ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001048
Christopher Faulet8ef75252017-02-20 22:56:03 +01001049 /* Add "healthcheck" K/V item */
1050 sz = SLEN(HEALTHCHECK_KEY);
1051 if (spoe_encode_buffer(HEALTHCHECK_KEY, sz, &frame, end) == -1)
1052 return -1;
1053 *frame++ = (SPOE_DATA_T_BOOL | SPOE_DATA_FL_TRUE);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001054
Christopher Faulet8ef75252017-02-20 22:56:03 +01001055 *len = frame - buf;
1056 sz = htonl(*len - 4);
1057 memcpy(buf, (char *)&sz, 4);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001058
Christopher Faulet8ef75252017-02-20 22:56:03 +01001059 if ((*req = malloc(*len)) == NULL)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001060 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001061 memcpy(*req, buf, *len);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001062 return 0;
1063}
1064
1065/* This function is used in checks.c and declared in proto/checks.h. It decode
1066 * the response received from an agent during a healthcheck. It returns 0 on
1067 * success and -1 if an error occurred. */
1068int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001069spoe_handle_healthcheck_response(char *frame, size_t size, char *err, int errlen)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001070{
Christopher Faulet42bfa462017-01-04 14:14:19 +01001071 struct appctx appctx;
1072 struct spoe_appctx spoe_appctx;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001073
Christopher Faulet42bfa462017-01-04 14:14:19 +01001074 memset(&appctx, 0, sizeof(appctx));
1075 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001076
Christopher Faulet42bfa462017-01-04 14:14:19 +01001077 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001078 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001079
Christopher Faulet8ef75252017-02-20 22:56:03 +01001080 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1081 spoe_handle_agentdiscon_frame(&appctx, frame, size);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001082 goto error;
1083 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001084 if (spoe_handle_agenthello_frame(&appctx, frame, size) <= 0)
1085 goto error;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001086
1087 return 0;
1088
1089 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001090 if (SPOE_APPCTX(&appctx)->status_code >= SPOE_FRM_ERRS)
1091 SPOE_APPCTX(&appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
1092 strncpy(err, spoe_frm_err_reasons[SPOE_APPCTX(&appctx)->status_code], errlen);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001093 return -1;
1094}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001095
Christopher Fauleta1cda022016-12-21 08:58:06 +01001096/* Send a SPOE frame to an agent. It returns -1 when an error occurred, 0 when
1097 * the frame can be ignored, 1 to retry later, and the frame legnth on
1098 * success. */
1099static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001100spoe_send_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001101{
1102 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001103 int ret;
1104 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001105
1106 if (si_ic(si)->buf == &buf_empty)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001107 goto retry;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001108
Christopher Faulet8ef75252017-02-20 22:56:03 +01001109 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1110 * length. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001111 netint = htonl(framesz);
1112 memcpy(buf, (char *)&netint, 4);
1113 ret = bi_putblk(si_ic(si), buf, framesz+4);
1114
1115 if (ret <= 0) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001116 if (ret == -1) {
1117 retry:
1118 si_applet_cant_put(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001119 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001120 }
1121 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001122 return -1; /* error */
1123 }
1124 return framesz;
1125}
1126
1127/* Receive a SPOE frame from an agent. It return -1 when an error occurred, 0
1128 * when the frame can be ignored, 1 to retry later and the frame length on
1129 * success. */
1130static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001131spoe_recv_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001132{
1133 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001134 int ret;
1135 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001136
1137 if (si_oc(si)->buf == &buf_empty)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001138 goto retry;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001139
1140 ret = bo_getblk(si_oc(si), (char *)&netint, 4, 0);
1141 if (ret > 0) {
1142 framesz = ntohl(netint);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001143 if (framesz > SPOE_APPCTX(appctx)->max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001144 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001145 return -1;
1146 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001147 ret = bo_getblk(si_oc(si), buf, framesz, 4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001148 }
1149 if (ret <= 0) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001150 if (ret == 0) {
1151 retry:
Christopher Fauleta1cda022016-12-21 08:58:06 +01001152 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001153 }
1154 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001155 return -1; /* error */
1156 }
1157 return framesz;
1158}
1159
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001160/********************************************************************
1161 * Functions that manage the SPOE applet
1162 ********************************************************************/
Christopher Faulet4596fb72017-01-11 14:05:19 +01001163static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001164spoe_wakeup_appctx(struct appctx *appctx)
Christopher Faulet4596fb72017-01-11 14:05:19 +01001165{
1166 si_applet_want_get(appctx->owner);
1167 si_applet_want_put(appctx->owner);
1168 appctx_wakeup(appctx);
1169 return 1;
1170}
1171
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001172/* Callback function that catches applet timeouts. If a timeout occurred, we set
1173 * <appctx->st1> flag and the SPOE applet is woken up. */
1174static struct task *
Christopher Faulet8ef75252017-02-20 22:56:03 +01001175spoe_process_appctx(struct task * task)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001176{
1177 struct appctx *appctx = task->context;
1178
1179 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1180 if (tick_is_expired(task->expire, now_ms)) {
1181 task->expire = TICK_ETERNITY;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001182 appctx->st1 = SPOE_APPCTX_ERR_TOUT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001183 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001184 spoe_wakeup_appctx(appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001185 return task;
1186}
1187
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001188/* Callback function that releases a SPOE applet. This happens when the
1189 * connection with the agent is closed. */
1190static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001191spoe_release_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001192{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001193 struct stream_interface *si = appctx->owner;
1194 struct spoe_appctx *spoe_appctx = SPOE_APPCTX(appctx);
1195 struct spoe_agent *agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001196 struct spoe_context *ctx, *back;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001197
1198 if (spoe_appctx == NULL)
1199 return;
1200
1201 appctx->ctx.spoe.ptr = NULL;
1202 agent = spoe_appctx->agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001203
1204 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p\n",
1205 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1206 __FUNCTION__, appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001207
Christopher Faulet8ef75252017-02-20 22:56:03 +01001208 /* Remove applet from the list of running applets */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001209 agent->applets_act--;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001210 if (!LIST_ISEMPTY(&spoe_appctx->list)) {
1211 LIST_DEL(&spoe_appctx->list);
1212 LIST_INIT(&spoe_appctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001213 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001214
Christopher Faulet8ef75252017-02-20 22:56:03 +01001215 /* Shutdown the server connection, if needed */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001216 if (appctx->st0 != SPOE_APPCTX_ST_END) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001217 if (appctx->st0 == SPOE_APPCTX_ST_IDLE)
1218 agent->applets_idle--;
1219
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001220 appctx->st0 = SPOE_APPCTX_ST_END;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001221 if (spoe_appctx->status_code == SPOE_FRM_ERR_NONE)
1222 spoe_appctx->status_code = SPOE_FRM_ERR_IO;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001223
1224 si_shutw(si);
1225 si_shutr(si);
1226 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001227 }
1228
Christopher Faulet8ef75252017-02-20 22:56:03 +01001229 /* Destroy the task attached to this applet */
1230 if (spoe_appctx->task) {
1231 task_delete(spoe_appctx->task);
1232 task_free(spoe_appctx->task);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001233 }
1234
Christopher Faulet8ef75252017-02-20 22:56:03 +01001235 /* Notify all waiting streams */
1236 list_for_each_entry_safe(ctx, back, &spoe_appctx->waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001237 LIST_DEL(&ctx->list);
1238 LIST_INIT(&ctx->list);
1239 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001240 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001241 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001242 }
1243
Christopher Faulet8ef75252017-02-20 22:56:03 +01001244 /* If the applet was processing a fragmented frame, notify the
1245 * corresponding stream. */
1246 if (spoe_appctx->frag_ctx.ctx) {
1247 ctx = spoe_appctx->frag_ctx.ctx;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001248 ctx->frag_ctx.spoe_appctx = NULL;
1249 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001250 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001251 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1252 }
1253
Christopher Faulet8ef75252017-02-20 22:56:03 +01001254 /* Release allocated memory */
1255 spoe_release_buffer(&spoe_appctx->buffer,
1256 &spoe_appctx->buffer_wait);
1257 pool_free2(pool2_spoe_appctx, spoe_appctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001258
Christopher Fauleta1cda022016-12-21 08:58:06 +01001259 if (!LIST_ISEMPTY(&agent->applets))
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001260 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001261
Christopher Faulet8ef75252017-02-20 22:56:03 +01001262 /* If this was the last running applet, notify all waiting streams */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001263 list_for_each_entry_safe(ctx, back, &agent->sending_queue, list) {
1264 LIST_DEL(&ctx->list);
1265 LIST_INIT(&ctx->list);
1266 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001267 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001268 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001269 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001270 list_for_each_entry_safe(ctx, back, &agent->waiting_queue, list) {
1271 LIST_DEL(&ctx->list);
1272 LIST_INIT(&ctx->list);
1273 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001274 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001275 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1276 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001277
1278 end:
1279 /* Update runtinme agent info */
1280 agent->frame_size = agent->max_frame_size;
1281 list_for_each_entry(spoe_appctx, &agent->applets, list)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001282 agent->frame_size = MIN(spoe_appctx->max_frame_size,
1283 agent->frame_size);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001284}
1285
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001286static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001287spoe_handle_connect_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001288{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001289 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001290 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001291 char *frame, *buf;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001292 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001293
Christopher Fauleta1cda022016-12-21 08:58:06 +01001294 if (si->state <= SI_ST_CON) {
1295 si_applet_want_put(si);
1296 task_wakeup(si_strm(si)->task, TASK_WOKEN_MSG);
1297 goto stop;
1298 }
Christopher Fauletb067b062017-01-04 16:39:11 +01001299 if (si->state != SI_ST_EST) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001300 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001301 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001302 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001303
Christopher Fauleta1cda022016-12-21 08:58:06 +01001304 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001305 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1306 " - Connection timed out\n",
1307 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1308 __FUNCTION__, appctx);
1309 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001310 goto exit;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001311 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001312
Christopher Faulet42bfa462017-01-04 14:14:19 +01001313 if (SPOE_APPCTX(appctx)->task->expire == TICK_ETERNITY)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001314 SPOE_APPCTX(appctx)->task->expire =
1315 tick_add_ifset(now_ms, agent->timeout.hello);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001316
Christopher Faulet8ef75252017-02-20 22:56:03 +01001317 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1318 * length. */
1319 buf = trash.str; frame = buf+4;
1320 ret = spoe_prepare_hahello_frame(appctx, frame,
1321 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001322 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001323 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001324
1325 switch (ret) {
1326 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001327 case 0: /* ignore => an error, cannot be ignored */
1328 goto exit;
1329
1330 case 1: /* retry later */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001331 goto stop;
1332
Christopher Faulet8ef75252017-02-20 22:56:03 +01001333 default:
1334 /* HELLO frame successfully sent, now wait for the
1335 * reply. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001336 appctx->st0 = SPOE_APPCTX_ST_CONNECTING;
1337 goto next;
1338 }
1339
1340 next:
1341 return 0;
1342 stop:
1343 return 1;
1344 exit:
1345 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1346 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001347}
1348
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001349static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001350spoe_handle_connecting_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001351{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001352 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001353 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001354 char *frame;
1355 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001356
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001357
Christopher Fauletb067b062017-01-04 16:39:11 +01001358 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001359 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001360 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001361 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001362
Christopher Fauleta1cda022016-12-21 08:58:06 +01001363 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001364 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1365 " - Connection timed out\n",
1366 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1367 __FUNCTION__, appctx);
1368 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001369 goto exit;
1370 }
1371
Christopher Faulet8ef75252017-02-20 22:56:03 +01001372 frame = trash.str; trash.len = 0;
1373 ret = spoe_recv_frame(appctx, frame,
1374 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001375 if (ret > 1) {
1376 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1377 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1378 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001379 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001380 trash.len = ret + 4;
1381 ret = spoe_handle_agenthello_frame(appctx, frame, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001382 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001383
Christopher Fauleta1cda022016-12-21 08:58:06 +01001384 switch (ret) {
1385 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001386 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001387 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1388 goto next;
1389
1390 case 1: /* retry later */
1391 goto stop;
1392
1393 default:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001394 /* HELLO handshake is finished, set the idle timeout and
1395 * add the applet in the list of running applets. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001396 agent->applets_idle++;
1397 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001398 LIST_DEL(&SPOE_APPCTX(appctx)->list);
1399 LIST_ADD(&agent->applets, &SPOE_APPCTX(appctx)->list);
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001400
1401 /* Update runtinme agent info */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001402 agent->frame_size = MIN(SPOE_APPCTX(appctx)->max_frame_size,
1403 agent->frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001404 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001405 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001406
Christopher Fauleta1cda022016-12-21 08:58:06 +01001407 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001408 /* Do not forget to remove processed frame from the output buffer */
1409 if (trash.len)
1410 bo_skip(si_oc(si), trash.len);
1411
1412 SPOE_APPCTX(appctx)->task->expire =
1413 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001414 return 0;
1415 stop:
1416 return 1;
1417 exit:
1418 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1419 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001420}
1421
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001422
Christopher Fauleta1cda022016-12-21 08:58:06 +01001423static int
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001424spoe_handle_sending_frame_appctx(struct appctx *appctx, int *skip)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001425{
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001426 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
1427 struct spoe_context *ctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001428 char *frame, *buf;
1429 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001430
Christopher Faulet8ef75252017-02-20 22:56:03 +01001431 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1432 * length. */
1433 buf = trash.str; frame = buf+4;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001434
1435 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY) {
1436 ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
1437 ret = spoe_prepare_hafrag_frame(appctx, ctx, frame,
1438 SPOE_APPCTX(appctx)->max_frame_size);
1439 }
1440 else if (LIST_ISEMPTY(&agent->sending_queue)) {
1441 *skip = 1;
1442 ret = 1;
1443 goto end;
1444 }
1445 else {
1446 ctx = LIST_NEXT(&agent->sending_queue, typeof(ctx), list);
1447 ret = spoe_prepare_hanotify_frame(appctx, ctx, frame,
1448 SPOE_APPCTX(appctx)->max_frame_size);
1449
1450 }
1451
Christopher Faulet8ef75252017-02-20 22:56:03 +01001452 if (ret > 1)
1453 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001454
Christopher Faulet8ef75252017-02-20 22:56:03 +01001455 switch (ret) {
1456 case -1: /* error */
1457 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1458 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001459
Christopher Faulet8ef75252017-02-20 22:56:03 +01001460 case 0: /* ignore */
1461 if (ctx == NULL)
1462 goto abort_frag_frame;
1463
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001464 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001465 LIST_DEL(&ctx->list);
1466 LIST_INIT(&ctx->list);
1467 ctx->state = SPOE_CTX_ST_ERROR;
1468 ctx->status_code = (SPOE_APPCTX(appctx)->status_code + 0x100);
1469 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1470 break;
1471
1472 case 1: /* retry */
1473 *skip = 1;
1474 break;
1475
1476 default:
1477 if (ctx == NULL)
1478 goto abort_frag_frame;
1479
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001480 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001481 LIST_DEL(&ctx->list);
1482 LIST_INIT(&ctx->list);
1483 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) ||
1484 (ctx->frag_ctx.flags & SPOE_FRM_FL_FIN))
1485 goto no_frag_frame_sent;
1486 else {
1487 *skip = 1;
1488 goto frag_frame_sent;
1489 }
1490 }
1491 goto end;
1492
1493 frag_frame_sent:
1494 appctx->st0 = SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY;
1495 SPOE_APPCTX(appctx)->frag_ctx.ctx = ctx;
1496 SPOE_APPCTX(appctx)->frag_ctx.cursid = ctx->stream_id;
1497 SPOE_APPCTX(appctx)->frag_ctx.curfid = ctx->frame_id;
1498
1499 ctx->frag_ctx.spoe_appctx = SPOE_APPCTX(appctx);
1500 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
1501 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1502 goto end;
1503
1504 no_frag_frame_sent:
1505 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
1506 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1507 LIST_ADDQ(&agent->waiting_queue, &ctx->list);
1508 }
1509 else if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_PIPELINING) {
1510 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1511 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1512 }
1513 else {
1514 appctx->st0 = SPOE_APPCTX_ST_WAITING_SYNC_ACK;
1515 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1516 }
1517 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1518 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1519 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1520
1521 ctx->frag_ctx.spoe_appctx = NULL;
1522 ctx->state = SPOE_CTX_ST_WAITING_ACK;
1523 goto end;
1524
1525 abort_frag_frame:
1526 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1527 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1528 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1529 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1530 goto end;
1531
1532 end:
1533 return ret;
1534}
1535
1536static int
1537spoe_handle_receiving_frame_appctx(struct appctx *appctx, int *skip)
1538{
1539 struct spoe_context *ctx = NULL;
1540 char *frame;
1541 int ret;
1542
1543 frame = trash.str; trash.len = 0;
1544 ret = spoe_recv_frame(appctx, frame,
1545 SPOE_APPCTX(appctx)->max_frame_size);
1546 if (ret > 1) {
1547 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1548 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1549 goto end;
1550 }
1551 trash.len = ret + 4;
1552 ret = spoe_handle_agentack_frame(appctx, &ctx, frame, ret);
1553 }
1554 switch (ret) {
1555 case -1: /* error */
1556 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1557 break;
1558
1559 case 0: /* ignore */
1560 break;
1561
1562 case 1: /* retry */
1563 *skip = 1;
1564 break;
1565
1566 default:
1567 LIST_DEL(&ctx->list);
1568 LIST_INIT(&ctx->list);
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001569
1570 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY &&
1571 ctx == SPOE_APPCTX(appctx)->frag_ctx.ctx) {
1572 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1573 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1574 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1575 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1576 }
1577 else if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1578 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1579
Christopher Faulet8ef75252017-02-20 22:56:03 +01001580 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1581 break;
1582 }
1583
1584 /* Do not forget to remove processed frame from the output buffer */
1585 if (trash.len)
1586 bo_skip(si_oc(appctx->owner), trash.len);
1587 end:
1588 return ret;
1589}
1590
1591static int
1592spoe_handle_processing_appctx(struct appctx *appctx)
1593{
1594 struct stream_interface *si = appctx->owner;
1595 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001596 unsigned int fpa = 0;
1597 int ret, skip_sending = 0, skip_receiving = 0;
1598
1599 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
1600 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1601 goto exit;
1602 }
1603
1604 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
1605 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
1606 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1607 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1608 goto next;
1609 }
1610
1611 process:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001612 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1613 " - process: fpa=%u/%u - skip_sending=%d - skip_receiving=%d"
1614 " - appctx-state=%s\n",
1615 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1616 __FUNCTION__, appctx, fpa, agent->max_fpa,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001617 skip_sending, skip_receiving,
1618 spoe_appctx_state_str[appctx->st0]);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001619
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001620 if (fpa > agent->max_fpa)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001621 goto stop;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001622 else if (skip_sending || appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001623 if (skip_receiving)
1624 goto stop;
1625 goto recv_frame;
1626 }
Christopher Faulet4596fb72017-01-11 14:05:19 +01001627
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001628 /* send_frame */
1629 ret = spoe_handle_sending_frame_appctx(appctx, &skip_sending);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001630 switch (ret) {
1631 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001632 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001633
Christopher Fauleta1cda022016-12-21 08:58:06 +01001634 case 0: /* ignore */
1635 agent->sending_rate++;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001636 fpa++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001637 break;
1638
Christopher Fauleta1cda022016-12-21 08:58:06 +01001639 case 1: /* retry */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001640 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001641
Christopher Fauleta1cda022016-12-21 08:58:06 +01001642 default:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001643 agent->sending_rate++;
1644 fpa++;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001645 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001646 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001647 if (fpa > agent->max_fpa)
1648 goto stop;
1649
1650 recv_frame:
1651 if (skip_receiving)
1652 goto process;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001653 ret = spoe_handle_receiving_frame_appctx(appctx, &skip_receiving);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001654 switch (ret) {
1655 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001656 goto next;
1657
1658 case 0: /* ignore */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001659 fpa++;
1660 break;
1661
1662 case 1: /* retry */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001663 break;
1664
1665 default:
Christopher Fauleta1cda022016-12-21 08:58:06 +01001666 fpa++;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001667 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001668 }
1669 goto process;
1670
1671 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001672 SPOE_APPCTX(appctx)->task->expire =
1673 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001674 return 0;
1675 stop:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001676 if (appctx->st0 == SPOE_APPCTX_ST_PROCESSING) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001677 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001678 agent->applets_idle++;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001679 }
Christopher Faulet42bfa462017-01-04 14:14:19 +01001680 if (fpa || (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_PERSIST)) {
1681 LIST_DEL(&SPOE_APPCTX(appctx)->list);
1682 LIST_ADD(&agent->applets, &SPOE_APPCTX(appctx)->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001683 if (fpa)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001684 SPOE_APPCTX(appctx)->task->expire =
1685 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001686 }
1687 return 1;
1688
1689 exit:
1690 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1691 return 0;
1692}
1693
1694static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001695spoe_handle_disconnect_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001696{
1697 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001698 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001699 char *frame, *buf;
1700 int ret;
Christopher Fauletb067b062017-01-04 16:39:11 +01001701
Christopher Fauleta1cda022016-12-21 08:58:06 +01001702 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO)
1703 goto exit;
1704
1705 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT)
1706 goto exit;
1707
Christopher Faulet8ef75252017-02-20 22:56:03 +01001708 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1709 * length. */
1710 buf = trash.str; frame = buf+4;
1711 ret = spoe_prepare_hadiscon_frame(appctx, frame,
1712 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001713 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001714 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001715
1716 switch (ret) {
1717 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001718 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001719 goto exit;
1720
1721 case 1: /* retry */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001722 goto stop;
1723
1724 default:
1725 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1726 " - disconnected by HAProxy (%d): %s\n",
1727 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001728 __FUNCTION__, appctx,
1729 SPOE_APPCTX(appctx)->status_code,
1730 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001731
1732 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1733 goto next;
1734 }
1735
1736 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001737 SPOE_APPCTX(appctx)->task->expire =
1738 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001739 return 0;
1740 stop:
1741 return 1;
1742 exit:
1743 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1744 return 0;
1745}
1746
1747static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001748spoe_handle_disconnecting_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001749{
1750 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001751 char *frame;
1752 int ret;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001753
Christopher Fauletb067b062017-01-04 16:39:11 +01001754 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001755 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001756 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001757 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001758
Christopher Fauletb067b062017-01-04 16:39:11 +01001759 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001760 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001761 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001762 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001763
Christopher Faulet8ef75252017-02-20 22:56:03 +01001764 frame = trash.str; trash.len = 0;
1765 ret = spoe_recv_frame(appctx, frame,
1766 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001767 if (ret > 1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001768 trash.len = ret + 4;
1769 ret = spoe_handle_agentdiscon_frame(appctx, frame, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001770 }
1771
1772 switch (ret) {
1773 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001774 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1775 " - error on frame (%s)\n",
1776 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001777 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Fauleta1cda022016-12-21 08:58:06 +01001778 __FUNCTION__, appctx,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001779 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001780 goto exit;
1781
1782 case 0: /* ignore */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001783 goto next;
1784
1785 case 1: /* retry */
1786 goto stop;
1787
1788 default:
Christopher Fauleta1cda022016-12-21 08:58:06 +01001789 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001790 " - disconnected by peer (%d): %.*s\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01001791 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001792 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001793 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->status_code,
1794 SPOE_APPCTX(appctx)->rlen, SPOE_APPCTX(appctx)->reason);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001795 goto exit;
1796 }
1797
1798 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001799 /* Do not forget to remove processed frame from the output buffer */
1800 if (trash.len)
1801 bo_skip(si_oc(appctx->owner), trash.len);
1802
Christopher Fauleta1cda022016-12-21 08:58:06 +01001803 return 0;
1804 stop:
1805 return 1;
1806 exit:
1807 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1808 return 0;
1809}
1810
1811/* I/O Handler processing messages exchanged with the agent */
1812static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001813spoe_handle_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001814{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001815 struct stream_interface *si = appctx->owner;
1816 struct spoe_agent *agent;
1817
1818 if (SPOE_APPCTX(appctx) == NULL)
1819 return;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001820
Christopher Faulet8ef75252017-02-20 22:56:03 +01001821 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
1822 agent = SPOE_APPCTX(appctx)->agent;
Christopher Fauletb067b062017-01-04 16:39:11 +01001823
Christopher Fauleta1cda022016-12-21 08:58:06 +01001824 switchstate:
1825 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1826 " - appctx-state=%s\n",
1827 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1828 __FUNCTION__, appctx, spoe_appctx_state_str[appctx->st0]);
1829
1830 switch (appctx->st0) {
1831 case SPOE_APPCTX_ST_CONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001832 if (spoe_handle_connect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001833 goto out;
1834 goto switchstate;
1835
1836 case SPOE_APPCTX_ST_CONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001837 if (spoe_handle_connecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001838 goto out;
1839 goto switchstate;
1840
1841 case SPOE_APPCTX_ST_IDLE:
1842 if (stopping &&
1843 LIST_ISEMPTY(&agent->sending_queue) &&
Christopher Faulet42bfa462017-01-04 14:14:19 +01001844 LIST_ISEMPTY(&SPOE_APPCTX(appctx)->waiting_queue)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001845 SPOE_APPCTX(appctx)->task->expire =
1846 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001847 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001848 goto switchstate;
1849 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001850 agent->applets_idle--;
1851 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1852 /* fall through */
1853
1854 case SPOE_APPCTX_ST_PROCESSING:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001855 case SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY:
1856 case SPOE_APPCTX_ST_WAITING_SYNC_ACK:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001857 if (spoe_handle_processing_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001858 goto out;
1859 goto switchstate;
1860
1861 case SPOE_APPCTX_ST_DISCONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001862 if (spoe_handle_disconnect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001863 goto out;
1864 goto switchstate;
1865
1866 case SPOE_APPCTX_ST_DISCONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001867 if (spoe_handle_disconnecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001868 goto out;
1869 goto switchstate;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001870
1871 case SPOE_APPCTX_ST_EXIT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001872 appctx->st0 = SPOE_APPCTX_ST_END;
1873 SPOE_APPCTX(appctx)->task->expire = TICK_ETERNITY;
1874
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001875 si_shutw(si);
1876 si_shutr(si);
1877 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001878 /* fall through */
1879
1880 case SPOE_APPCTX_ST_END:
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001881 return;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001882 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001883 out:
Christopher Faulet42bfa462017-01-04 14:14:19 +01001884 if (SPOE_APPCTX(appctx)->task->expire != TICK_ETERNITY)
1885 task_queue(SPOE_APPCTX(appctx)->task);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001886 si_oc(si)->flags |= CF_READ_DONTWAIT;
1887 task_wakeup(si_strm(si)->task, TASK_WOKEN_IO);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001888}
1889
1890struct applet spoe_applet = {
1891 .obj_type = OBJ_TYPE_APPLET,
1892 .name = "<SPOE>", /* used for logging */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001893 .fct = spoe_handle_appctx,
1894 .release = spoe_release_appctx,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001895};
1896
1897/* Create a SPOE applet. On success, the created applet is returned, else
1898 * NULL. */
1899static struct appctx *
Christopher Faulet8ef75252017-02-20 22:56:03 +01001900spoe_create_appctx(struct spoe_config *conf)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001901{
1902 struct appctx *appctx;
1903 struct session *sess;
1904 struct task *task;
1905 struct stream *strm;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001906
1907 if ((appctx = appctx_new(&spoe_applet)) == NULL)
1908 goto out_error;
1909
Christopher Faulet42bfa462017-01-04 14:14:19 +01001910 appctx->ctx.spoe.ptr = pool_alloc_dirty(pool2_spoe_appctx);
1911 if (SPOE_APPCTX(appctx) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001912 goto out_free_appctx;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001913 memset(appctx->ctx.spoe.ptr, 0, pool2_spoe_appctx->size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001914
Christopher Faulet42bfa462017-01-04 14:14:19 +01001915 appctx->st0 = SPOE_APPCTX_ST_CONNECT;
1916 if ((SPOE_APPCTX(appctx)->task = task_new()) == NULL)
1917 goto out_free_spoe_appctx;
1918
1919 SPOE_APPCTX(appctx)->owner = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001920 SPOE_APPCTX(appctx)->task->process = spoe_process_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001921 SPOE_APPCTX(appctx)->task->expire = TICK_ETERNITY;
1922 SPOE_APPCTX(appctx)->task->context = appctx;
1923 SPOE_APPCTX(appctx)->agent = conf->agent;
1924 SPOE_APPCTX(appctx)->version = 0;
1925 SPOE_APPCTX(appctx)->max_frame_size = conf->agent->max_frame_size;
1926 SPOE_APPCTX(appctx)->flags = 0;
Christopher Fauletb067b062017-01-04 16:39:11 +01001927 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001928 SPOE_APPCTX(appctx)->buffer = &buf_empty;
1929
1930 LIST_INIT(&SPOE_APPCTX(appctx)->buffer_wait.list);
1931 SPOE_APPCTX(appctx)->buffer_wait.target = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001932 SPOE_APPCTX(appctx)->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001933
1934 LIST_INIT(&SPOE_APPCTX(appctx)->list);
1935 LIST_INIT(&SPOE_APPCTX(appctx)->waiting_queue);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001936
Willy Tarreau5820a362016-12-22 15:59:02 +01001937 sess = session_new(&conf->agent_fe, NULL, &appctx->obj_type);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001938 if (!sess)
1939 goto out_free_spoe;
1940
1941 if ((task = task_new()) == NULL)
1942 goto out_free_sess;
1943
1944 if ((strm = stream_new(sess, task, &appctx->obj_type)) == NULL)
1945 goto out_free_task;
1946
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001947 stream_set_backend(strm, conf->agent->b.be);
1948
1949 /* applet is waiting for data */
1950 si_applet_cant_get(&strm->si[0]);
1951 appctx_wakeup(appctx);
1952
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001953 strm->do_log = NULL;
1954 strm->res.flags |= CF_READ_DONTWAIT;
1955
1956 conf->agent_fe.feconn++;
1957 jobs++;
1958 totalconn++;
1959
Christopher Faulet42bfa462017-01-04 14:14:19 +01001960 task_wakeup(SPOE_APPCTX(appctx)->task, TASK_WOKEN_INIT);
1961 LIST_ADDQ(&conf->agent->applets, &SPOE_APPCTX(appctx)->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001962 conf->agent->applets_act++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001963 return appctx;
1964
1965 /* Error unrolling */
1966 out_free_task:
1967 task_free(task);
1968 out_free_sess:
1969 session_free(sess);
1970 out_free_spoe:
Christopher Faulet42bfa462017-01-04 14:14:19 +01001971 task_free(SPOE_APPCTX(appctx)->task);
1972 out_free_spoe_appctx:
1973 pool_free2(pool2_spoe_appctx, SPOE_APPCTX(appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001974 out_free_appctx:
1975 appctx_free(appctx);
1976 out_error:
1977 return NULL;
1978}
1979
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001980static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001981spoe_queue_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001982{
1983 struct spoe_config *conf = FLT_CONF(ctx->filter);
1984 struct spoe_agent *agent = conf->agent;
1985 struct appctx *appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001986 struct spoe_appctx *spoe_appctx;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001987 unsigned int min_applets;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001988
Christopher Fauleta1cda022016-12-21 08:58:06 +01001989 min_applets = min_applets_act(agent);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001990
Christopher Fauleta1cda022016-12-21 08:58:06 +01001991 /* Check if we need to create a new SPOE applet or not. */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001992 if (agent->applets_act >= min_applets &&
1993 agent->applets_idle &&
1994 agent->sending_rate)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001995 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001996
1997 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauleta1cda022016-12-21 08:58:06 +01001998 " - try to create new SPOE appctx\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001999 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
2000 ctx->strm);
2001
Christopher Fauleta1cda022016-12-21 08:58:06 +01002002 /* Do not try to create a new applet if there is no server up for the
2003 * agent's backend. */
2004 if (!agent->b.be->srv_act && !agent->b.be->srv_bck) {
2005 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2006 " - cannot create SPOE appctx: no server up\n",
2007 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2008 __FUNCTION__, ctx->strm);
2009 goto end;
2010 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002011
Christopher Fauleta1cda022016-12-21 08:58:06 +01002012 /* Do not try to create a new applet if we have reached the maximum of
2013 * connection per seconds */
Christopher Faulet48026722016-11-16 15:01:12 +01002014 if (agent->cps_max > 0) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002015 if (!freq_ctr_remain(&agent->conn_per_sec, agent->cps_max, 0)) {
2016 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2017 " - cannot create SPOE appctx: max CPS reached\n",
2018 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2019 __FUNCTION__, ctx->strm);
2020 goto end;
2021 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002022 }
2023
Christopher Faulet8ef75252017-02-20 22:56:03 +01002024 appctx = spoe_create_appctx(conf);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002025 if (appctx == NULL) {
2026 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2027 " - failed to create SPOE appctx\n",
2028 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2029 __FUNCTION__, ctx->strm);
Christopher Faulet72bcc472017-01-04 16:39:41 +01002030 send_log(ctx->strm->be, LOG_EMERG,
2031 "SPOE: [%s] failed to create SPOE applet\n",
2032 agent->id);
2033
Christopher Fauleta1cda022016-12-21 08:58:06 +01002034 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002035 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002036 if (agent->applets_act <= min_applets)
Christopher Faulet42bfa462017-01-04 14:14:19 +01002037 SPOE_APPCTX(appctx)->flags |= SPOE_APPCTX_FL_PERSIST;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002038
Christopher Fauleta1cda022016-12-21 08:58:06 +01002039 /* Increase the per-process number of cumulated connections */
2040 if (agent->cps_max > 0)
2041 update_freq_ctr(&agent->conn_per_sec, 1);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002042
Christopher Fauleta1cda022016-12-21 08:58:06 +01002043 end:
2044 /* The only reason to return an error is when there is no applet */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002045 if (LIST_ISEMPTY(&agent->applets)) {
2046 ctx->status_code = SPOE_CTX_ERR_RES;
2047 return -1;
2048 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002049
Christopher Fauleta1cda022016-12-21 08:58:06 +01002050 /* Add the SPOE context in the sending queue and update all running
2051 * info */
2052 LIST_ADDQ(&agent->sending_queue, &ctx->list);
2053 if (agent->sending_rate)
2054 agent->sending_rate--;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002055
2056 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002057 " - Add stream in sending queue"
2058 " - applets_act=%u - applets_idle=%u - sending_rate=%u\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002059 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
Christopher Faulet8ef75252017-02-20 22:56:03 +01002060 ctx->strm, agent->applets_act, agent->applets_idle,
2061 agent->sending_rate);
Christopher Fauletf7a30922016-11-10 15:04:51 +01002062
Christopher Fauleta1cda022016-12-21 08:58:06 +01002063 /* Finally try to wakeup the first IDLE applet found and move it at the
2064 * end of the list. */
Christopher Faulet42bfa462017-01-04 14:14:19 +01002065 list_for_each_entry(spoe_appctx, &agent->applets, list) {
2066 appctx = spoe_appctx->owner;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002067 if (appctx->st0 == SPOE_APPCTX_ST_IDLE) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01002068 spoe_wakeup_appctx(appctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01002069 LIST_DEL(&spoe_appctx->list);
2070 LIST_ADDQ(&agent->applets, &spoe_appctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002071 break;
2072 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002073 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002074 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002075}
2076
2077/***************************************************************************
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002078 * Functions that encode SPOE messages
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002079 **************************************************************************/
Christopher Faulet8ef75252017-02-20 22:56:03 +01002080/* Encode SPOE messages for a specific event. Info in <ctx->frag_ctx>, if any,
2081 * are used to handle fragmented content. On success it returns 1. If an error
2082 * occurred, -1 is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002083static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002084spoe_encode_messages(struct stream *s, struct spoe_context *ctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002085 struct list *messages, int dir)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002086{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002087 struct spoe_config *conf = FLT_CONF(ctx->filter);
2088 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002089 struct spoe_message *msg;
2090 struct sample *smp;
2091 struct spoe_arg *arg;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002092 char *p, *end;
2093 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002094
Christopher Faulet8ef75252017-02-20 22:56:03 +01002095 p = ctx->buffer->p;
2096 end = p + agent->frame_size - FRAME_HDR_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002097
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002098 /* Resume encoding of a SPOE message */
2099 if (ctx->frag_ctx.curmsg != NULL) {
2100 msg = ctx->frag_ctx.curmsg;
2101 goto encode_message;
2102 }
2103
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002104 /* Loop on messages */
2105 list_for_each_entry(msg, messages, list) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002106 ctx->frag_ctx.curmsg = msg;
2107 ctx->frag_ctx.curarg = NULL;
2108 ctx->frag_ctx.curoff = UINT_MAX;
2109
2110 encode_message:
2111 /* Resume encoding of a SPOE argument */
2112 if (ctx->frag_ctx.curarg != NULL) {
2113 arg = ctx->frag_ctx.curarg;
2114 goto encode_argument;
2115 }
2116
2117 if (ctx->frag_ctx.curoff != UINT_MAX)
2118 goto encode_msg_payload;
2119
Christopher Faulet8ef75252017-02-20 22:56:03 +01002120 /* Check if there is enough space for the message name and the
2121 * number of arguments. It implies <msg->id_len> is encoded on 2
2122 * bytes, at most (< 2288). */
2123 if (p + 2 + msg->id_len + 1 > end)
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002124 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002125
Christopher Faulet8ef75252017-02-20 22:56:03 +01002126 /* Encode the message name */
2127 if (spoe_encode_buffer(msg->id, msg->id_len, &p, end) == -1)
2128 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002129
Christopher Faulet8ef75252017-02-20 22:56:03 +01002130 /* Set the number of arguments for this message */
2131 *p++ = msg->nargs;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002132
2133 ctx->frag_ctx.curoff = 0;
2134 encode_msg_payload:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002135
2136 /* Loop on arguments */
2137 list_for_each_entry(arg, &msg->args, list) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002138 ctx->frag_ctx.curarg = arg;
2139 ctx->frag_ctx.curoff = UINT_MAX;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002140
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002141 encode_argument:
2142 if (ctx->frag_ctx.curoff != UINT_MAX)
2143 goto encode_arg_value;
2144
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002145 /* Encode the arguement name as a string. It can by NULL */
Christopher Faulet8ef75252017-02-20 22:56:03 +01002146 if (spoe_encode_buffer(arg->name, arg->name_len, &p, end) == -1)
2147 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002148
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002149 ctx->frag_ctx.curoff = 0;
2150 encode_arg_value:
2151
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002152 /* Fetch the arguement value */
Christopher Faulet8ef75252017-02-20 22:56:03 +01002153 smp = sample_process(s->be, s->sess, s,
2154 dir|SMP_OPT_FINAL, arg->expr, NULL);
2155 ret = spoe_encode_data(smp, &ctx->frag_ctx.curoff, &p, end);
2156 if (ret == -1 || ctx->frag_ctx.curoff)
2157 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002158 }
2159 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002160
2161 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002162 " - encode %s messages - spoe_appctx=%p"
2163 "- max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002164 (int)now.tv_sec, (int)now.tv_usec,
2165 agent->id, __FUNCTION__, s,
2166 ((ctx->flags & SPOE_CTX_FL_FRAGMENTED) ? "last fragment of" : "unfragmented"),
Christopher Faulet8ef75252017-02-20 22:56:03 +01002167 ctx->frag_ctx.spoe_appctx, (agent->frame_size - FRAME_HDR_SIZE),
2168 p - ctx->buffer->p);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002169
Christopher Faulet8ef75252017-02-20 22:56:03 +01002170 ctx->buffer->i = p - ctx->buffer->p;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002171 ctx->frag_ctx.curmsg = NULL;
2172 ctx->frag_ctx.curarg = NULL;
2173 ctx->frag_ctx.curoff = 0;
2174 ctx->frag_ctx.flags = SPOE_FRM_FL_FIN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002175 return 1;
2176
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002177 too_big:
Christopher Fauletcecd8522017-02-24 22:11:21 +01002178 if (!(agent->flags & SPOE_FL_SND_FRAGMENTATION)) {
2179 ctx->status_code = SPOE_CTX_ERR_TOO_BIG;
2180 return -1;
2181 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002182
2183 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002184 " - encode fragmented messages - spoe_appctx=%p"
2185 " - curmsg=%p - curarg=%p - curoff=%u"
2186 " - max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002187 (int)now.tv_sec, (int)now.tv_usec,
2188 agent->id, __FUNCTION__, s, ctx->frag_ctx.spoe_appctx,
2189 ctx->frag_ctx.curmsg, ctx->frag_ctx.curarg, ctx->frag_ctx.curoff,
Christopher Faulet8ef75252017-02-20 22:56:03 +01002190 (agent->frame_size - FRAME_HDR_SIZE), p - ctx->buffer->p);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002191
Christopher Faulet8ef75252017-02-20 22:56:03 +01002192 ctx->buffer->i = p - ctx->buffer->p;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002193 ctx->flags |= SPOE_CTX_FL_FRAGMENTED;
2194 ctx->frag_ctx.flags &= ~SPOE_FRM_FL_FIN;
2195 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002196}
2197
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002198
2199/***************************************************************************
2200 * Functions that handle SPOE actions
2201 **************************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002202/* Helper function to set a variable */
2203static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002204spoe_set_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002205 struct sample *smp)
2206{
2207 struct spoe_config *conf = FLT_CONF(ctx->filter);
2208 struct spoe_agent *agent = conf->agent;
2209 char varname[64];
2210
2211 memset(varname, 0, sizeof(varname));
2212 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2213 scope, agent->var_pfx, len, name);
2214 vars_set_by_name_ifexist(varname, len, smp);
2215}
2216
2217/* Helper function to unset a variable */
2218static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002219spoe_unset_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002220 struct sample *smp)
2221{
2222 struct spoe_config *conf = FLT_CONF(ctx->filter);
2223 struct spoe_agent *agent = conf->agent;
2224 char varname[64];
2225
2226 memset(varname, 0, sizeof(varname));
2227 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2228 scope, agent->var_pfx, len, name);
2229 vars_unset_by_name_ifexist(varname, len, smp);
2230}
2231
2232
Christopher Faulet8ef75252017-02-20 22:56:03 +01002233static inline int
2234spoe_decode_action_set_var(struct stream *s, struct spoe_context *ctx,
2235 char **buf, char *end, int dir)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002236{
Christopher Faulet8ef75252017-02-20 22:56:03 +01002237 char *str, *scope, *p = *buf;
2238 struct sample smp;
2239 uint64_t sz;
2240 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002241
Christopher Faulet8ef75252017-02-20 22:56:03 +01002242 if (p + 2 >= end)
2243 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002244
Christopher Faulet8ef75252017-02-20 22:56:03 +01002245 /* SET-VAR requires 3 arguments */
2246 if (*p++ != 3)
2247 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002248
Christopher Faulet8ef75252017-02-20 22:56:03 +01002249 switch (*p++) {
2250 case SPOE_SCOPE_PROC: scope = "proc"; break;
2251 case SPOE_SCOPE_SESS: scope = "sess"; break;
2252 case SPOE_SCOPE_TXN : scope = "txn"; break;
2253 case SPOE_SCOPE_REQ : scope = "req"; break;
2254 case SPOE_SCOPE_RES : scope = "res"; break;
2255 default: goto skip;
2256 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002257
Christopher Faulet8ef75252017-02-20 22:56:03 +01002258 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2259 goto skip;
2260 memset(&smp, 0, sizeof(smp));
2261 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002262
Christopher Faulet8ef75252017-02-20 22:56:03 +01002263 if (spoe_decode_data(&p, end, &smp) == -1)
2264 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002265
Christopher Faulet8ef75252017-02-20 22:56:03 +01002266 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2267 " - set-var '%s.%s.%.*s'\n",
2268 (int)now.tv_sec, (int)now.tv_usec,
2269 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2270 __FUNCTION__, s, scope,
2271 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2272 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002273
Christopher Faulet8ef75252017-02-20 22:56:03 +01002274 spoe_set_var(ctx, scope, str, sz, &smp);
Christopher Fauletb5cff602016-11-24 14:53:22 +01002275
Christopher Faulet8ef75252017-02-20 22:56:03 +01002276 ret = (p - *buf);
2277 *buf = p;
2278 return ret;
2279 skip:
2280 return 0;
2281}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002282
Christopher Faulet8ef75252017-02-20 22:56:03 +01002283static inline int
2284spoe_decode_action_unset_var(struct stream *s, struct spoe_context *ctx,
2285 char **buf, char *end, int dir)
2286{
2287 char *str, *scope, *p = *buf;
2288 struct sample smp;
2289 uint64_t sz;
2290 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002291
Christopher Faulet8ef75252017-02-20 22:56:03 +01002292 if (p + 2 >= end)
2293 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002294
Christopher Faulet8ef75252017-02-20 22:56:03 +01002295 /* UNSET-VAR requires 2 arguments */
2296 if (*p++ != 2)
2297 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002298
Christopher Faulet8ef75252017-02-20 22:56:03 +01002299 switch (*p++) {
2300 case SPOE_SCOPE_PROC: scope = "proc"; break;
2301 case SPOE_SCOPE_SESS: scope = "sess"; break;
2302 case SPOE_SCOPE_TXN : scope = "txn"; break;
2303 case SPOE_SCOPE_REQ : scope = "req"; break;
2304 case SPOE_SCOPE_RES : scope = "res"; break;
2305 default: goto skip;
2306 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002307
Christopher Faulet8ef75252017-02-20 22:56:03 +01002308 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2309 goto skip;
2310 memset(&smp, 0, sizeof(smp));
2311 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002312
Christopher Faulet8ef75252017-02-20 22:56:03 +01002313 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2314 " - unset-var '%s.%s.%.*s'\n",
2315 (int)now.tv_sec, (int)now.tv_usec,
2316 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2317 __FUNCTION__, s, scope,
2318 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2319 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002320
Christopher Faulet8ef75252017-02-20 22:56:03 +01002321 spoe_unset_var(ctx, scope, str, sz, &smp);
2322
2323 ret = (p - *buf);
2324 *buf = p;
2325 return ret;
2326 skip:
2327 return 0;
2328}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002329
Christopher Faulet8ef75252017-02-20 22:56:03 +01002330/* Process SPOE actions for a specific event. It returns 1 on success. If an
2331 * error occurred, 0 is returned. */
2332static int
2333spoe_process_actions(struct stream *s, struct spoe_context *ctx,
2334 enum spoe_event ev, int dir)
2335{
2336 char *p, *end;
2337 int ret;
2338
2339 p = ctx->buffer->p;
2340 end = p + ctx->buffer->i;
2341
2342 while (p < end) {
2343 enum spoe_action_type type;
2344
2345 type = *p++;
2346 switch (type) {
2347 case SPOE_ACT_T_SET_VAR:
2348 ret = spoe_decode_action_set_var(s, ctx, &p, end, dir);
2349 if (!ret)
2350 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002351 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002352
Christopher Faulet8ef75252017-02-20 22:56:03 +01002353 case SPOE_ACT_T_UNSET_VAR:
2354 ret = spoe_decode_action_unset_var(s, ctx, &p, end, dir);
2355 if (!ret)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002356 goto skip;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002357 break;
2358
2359 default:
2360 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002361 }
2362 }
2363
2364 return 1;
2365 skip:
2366 return 0;
2367}
2368
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002369/***************************************************************************
2370 * Functions that process SPOE events
2371 **************************************************************************/
2372static inline int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002373spoe_start_event_processing(struct spoe_context *ctx, int dir)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002374{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002375 /* If a process is already started for this SPOE context, retry
2376 * later. */
2377 if (ctx->flags & SPOE_CTX_FL_PROCESS)
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002378 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002379
2380 /* Set the right flag to prevent request and response processing
2381 * in same time. */
2382 ctx->flags |= ((dir == SMP_OPT_DIR_REQ)
2383 ? SPOE_CTX_FL_REQ_PROCESS
2384 : SPOE_CTX_FL_RSP_PROCESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002385 return 1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002386}
2387
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002388static inline void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002389spoe_stop_event_processing(struct spoe_context *ctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002390{
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002391 struct spoe_appctx *sa = ctx->frag_ctx.spoe_appctx;
2392
2393 if (sa) {
2394 sa->frag_ctx.ctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002395 spoe_wakeup_appctx(sa->owner);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002396 }
2397
Christopher Fauleta1cda022016-12-21 08:58:06 +01002398 /* Reset the flag to allow next processing */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002399 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002400
Christopher Fauletb067b062017-01-04 16:39:11 +01002401 ctx->status_code = 0;
2402
Christopher Fauleta1cda022016-12-21 08:58:06 +01002403 /* Reset processing timer */
2404 ctx->process_exp = TICK_ETERNITY;
2405
Christopher Faulet8ef75252017-02-20 22:56:03 +01002406 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002407
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002408 ctx->frag_ctx.spoe_appctx = NULL;
2409 ctx->frag_ctx.curmsg = NULL;
2410 ctx->frag_ctx.curarg = NULL;
2411 ctx->frag_ctx.curoff = 0;
2412 ctx->frag_ctx.flags = 0;
2413
Christopher Fauleta1cda022016-12-21 08:58:06 +01002414 if (!LIST_ISEMPTY(&ctx->list)) {
2415 LIST_DEL(&ctx->list);
2416 LIST_INIT(&ctx->list);
2417 }
2418}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002419
2420/* Process a SPOE event. First, this functions will process messages attached to
2421 * this event and send them to an agent in a NOTIFY frame. Then, it will wait a
2422 * ACK frame to process corresponding actions. During all the processing, it
2423 * returns 0 and it returns 1 when the processing is finished. If an error
2424 * occurred, -1 is returned. */
2425static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002426spoe_process_event(struct stream *s, struct spoe_context *ctx,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002427 enum spoe_event ev)
2428{
Christopher Fauletf7a30922016-11-10 15:04:51 +01002429 struct spoe_config *conf = FLT_CONF(ctx->filter);
2430 struct spoe_agent *agent = conf->agent;
2431 int dir, ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002432
2433 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2434 " - ctx-state=%s - event=%s\n",
2435 (int)now.tv_sec, (int)now.tv_usec,
Christopher Fauletf7a30922016-11-10 15:04:51 +01002436 agent->id, __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002437 spoe_event_str[ev]);
2438
2439 dir = ((ev < SPOE_EV_ON_SERVER_SESS) ? SMP_OPT_DIR_REQ : SMP_OPT_DIR_RES);
2440
2441 if (LIST_ISEMPTY(&(ctx->messages[ev])))
2442 goto out;
2443
2444 if (ctx->state == SPOE_CTX_ST_ERROR)
2445 goto error;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002446
2447 if (tick_is_expired(ctx->process_exp, now_ms) && ctx->state != SPOE_CTX_ST_DONE) {
2448 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2449 " - failed to process event '%s': timeout\n",
2450 (int)now.tv_sec, (int)now.tv_usec,
2451 agent->id, __FUNCTION__, s, spoe_event_str[ev]);
Christopher Fauletb067b062017-01-04 16:39:11 +01002452 ctx->status_code = SPOE_CTX_ERR_TOUT;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002453 goto error;
2454 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002455
2456 if (ctx->state == SPOE_CTX_ST_READY) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002457 if (agent->eps_max > 0) {
2458 if (!freq_ctr_remain(&agent->err_per_sec, agent->eps_max, 0)) {
2459 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2460 " - skip event '%s': max EPS reached\n",
2461 (int)now.tv_sec, (int)now.tv_usec,
2462 agent->id, __FUNCTION__, s, spoe_event_str[ev]);
2463 goto skip;
2464 }
2465 }
2466
Christopher Fauletf7a30922016-11-10 15:04:51 +01002467 if (!tick_isset(ctx->process_exp)) {
2468 ctx->process_exp = tick_add_ifset(now_ms, agent->timeout.processing);
2469 s->task->expire = tick_first((tick_is_expired(s->task->expire, now_ms) ? 0 : s->task->expire),
2470 ctx->process_exp);
2471 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01002472 ret = spoe_start_event_processing(ctx, dir);
Christopher Fauletb067b062017-01-04 16:39:11 +01002473 if (!ret)
2474 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002475
Christopher Faulet8ef75252017-02-20 22:56:03 +01002476 if (spoe_queue_context(ctx) < 0)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002477 goto error;
2478
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002479 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002480 /* fall through */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002481 }
2482
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002483 if (ctx->state == SPOE_CTX_ST_ENCODING_MSGS) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01002484 if (!spoe_acquire_buffer(&ctx->buffer, &ctx->buffer_wait))
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002485 goto out;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002486 ret = spoe_encode_messages(s, ctx, &(ctx->messages[ev]), dir);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002487 if (ret < 0)
2488 goto error;
2489 ctx->state = SPOE_CTX_ST_SENDING_MSGS;
2490 }
2491
2492 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS) {
2493 if (ctx->frag_ctx.spoe_appctx)
Christopher Faulet8ef75252017-02-20 22:56:03 +01002494 spoe_wakeup_appctx(ctx->frag_ctx.spoe_appctx->owner);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002495 ret = 0;
2496 goto out;
2497 }
2498
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002499 if (ctx->state == SPOE_CTX_ST_WAITING_ACK) {
2500 ret = 0;
2501 goto out;
2502 }
2503
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002504 if (ctx->state == SPOE_CTX_ST_DONE) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01002505 spoe_process_actions(s, ctx, ev, dir);
2506 ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002507 ctx->frame_id++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002508 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002509 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002510 }
2511
2512 out:
2513 return ret;
2514
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002515 error:
Christopher Faulet48026722016-11-16 15:01:12 +01002516 if (agent->eps_max > 0)
2517 update_freq_ctr(&agent->err_per_sec, 1);
2518
Christopher Faulet985532d2016-11-16 15:36:19 +01002519 if (agent->var_on_error) {
2520 struct sample smp;
2521
2522 memset(&smp, 0, sizeof(smp));
2523 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletb067b062017-01-04 16:39:11 +01002524 smp.data.u.sint = ctx->status_code;
Christopher Faulet985532d2016-11-16 15:36:19 +01002525 smp.data.type = SMP_T_BOOL;
2526
Christopher Faulet8ef75252017-02-20 22:56:03 +01002527 spoe_set_var(ctx, "txn", agent->var_on_error,
Christopher Faulet985532d2016-11-16 15:36:19 +01002528 strlen(agent->var_on_error), &smp);
2529 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002530 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2531 " - failed to create process event '%s': code=%u\n",
2532 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2533 __FUNCTION__, ctx->strm, spoe_event_str[ev],
2534 ctx->status_code);
Christopher Faulet72bcc472017-01-04 16:39:41 +01002535 send_log(ctx->strm->be, LOG_WARNING,
2536 "SPOE: [%s] failed to process event '%s': code=%u\n",
2537 agent->id, spoe_event_str[ev], ctx->status_code);
Christopher Faulet985532d2016-11-16 15:36:19 +01002538
Christopher Fauletea62c2a2016-11-14 10:54:21 +01002539 ctx->state = ((agent->flags & SPOE_FL_CONT_ON_ERR)
2540 ? SPOE_CTX_ST_READY
Christopher Fauletb067b062017-01-04 16:39:11 +01002541 : SPOE_CTX_ST_NONE);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002542 ret = 1;
2543 goto end;
2544
2545 skip:
2546 ctx->state = SPOE_CTX_ST_READY;
2547 ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002548
Christopher Fauleta1cda022016-12-21 08:58:06 +01002549 end:
Christopher Faulet8ef75252017-02-20 22:56:03 +01002550 spoe_stop_event_processing(ctx);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002551 return ret;
2552}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002553
2554/***************************************************************************
2555 * Functions that create/destroy SPOE contexts
2556 **************************************************************************/
Christopher Fauleta1cda022016-12-21 08:58:06 +01002557static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002558spoe_acquire_buffer(struct buffer **buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002559{
Christopher Faulet4596fb72017-01-11 14:05:19 +01002560 if (*buf != &buf_empty)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002561 return 1;
2562
Christopher Faulet4596fb72017-01-11 14:05:19 +01002563 if (!LIST_ISEMPTY(&buffer_wait->list)) {
2564 LIST_DEL(&buffer_wait->list);
2565 LIST_INIT(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002566 }
2567
Christopher Faulet4596fb72017-01-11 14:05:19 +01002568 if (b_alloc_margin(buf, global.tune.reserved_bufs))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002569 return 1;
2570
Christopher Faulet4596fb72017-01-11 14:05:19 +01002571 LIST_ADDQ(&buffer_wq, &buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002572 return 0;
2573}
2574
2575static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002576spoe_release_buffer(struct buffer **buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002577{
Christopher Faulet4596fb72017-01-11 14:05:19 +01002578 if (!LIST_ISEMPTY(&buffer_wait->list)) {
2579 LIST_DEL(&buffer_wait->list);
2580 LIST_INIT(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002581 }
2582
2583 /* Release the buffer if needed */
Christopher Faulet4596fb72017-01-11 14:05:19 +01002584 if (*buf != &buf_empty) {
2585 b_free(buf);
2586 offer_buffers(buffer_wait->target,
2587 tasks_run_queue + applets_active_queue);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002588 }
2589}
2590
Christopher Faulet4596fb72017-01-11 14:05:19 +01002591static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002592spoe_wakeup_context(struct spoe_context *ctx)
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002593{
2594 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
2595 return 1;
2596}
2597
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002598static struct spoe_context *
Christopher Faulet8ef75252017-02-20 22:56:03 +01002599spoe_create_context(struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002600{
2601 struct spoe_config *conf = FLT_CONF(filter);
2602 struct spoe_context *ctx;
2603
2604 ctx = pool_alloc_dirty(pool2_spoe_ctx);
2605 if (ctx == NULL) {
2606 return NULL;
2607 }
2608 memset(ctx, 0, sizeof(*ctx));
Christopher Fauletb067b062017-01-04 16:39:11 +01002609 ctx->filter = filter;
2610 ctx->state = SPOE_CTX_ST_NONE;
2611 ctx->status_code = SPOE_CTX_ERR_NONE;
2612 ctx->flags = 0;
2613 ctx->messages = conf->agent->messages;
2614 ctx->buffer = &buf_empty;
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002615 LIST_INIT(&ctx->buffer_wait.list);
2616 ctx->buffer_wait.target = ctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002617 ctx->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_context;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002618 LIST_INIT(&ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002619
Christopher Fauletf7a30922016-11-10 15:04:51 +01002620 ctx->stream_id = 0;
2621 ctx->frame_id = 1;
2622 ctx->process_exp = TICK_ETERNITY;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002623
2624 return ctx;
2625}
2626
2627static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002628spoe_destroy_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002629{
2630 if (!ctx)
2631 return;
2632
Christopher Faulet8ef75252017-02-20 22:56:03 +01002633 spoe_stop_event_processing(ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002634 pool_free2(pool2_spoe_ctx, ctx);
2635}
2636
2637static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002638spoe_reset_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002639{
2640 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01002641 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002642}
2643
2644
2645/***************************************************************************
2646 * Hooks that manage the filter lifecycle (init/check/deinit)
2647 **************************************************************************/
2648/* Signal handler: Do a soft stop, wakeup SPOE applet */
2649static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002650spoe_sig_stop(struct sig_handler *sh)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002651{
2652 struct proxy *p;
2653
2654 p = proxy;
2655 while (p) {
2656 struct flt_conf *fconf;
2657
2658 list_for_each_entry(fconf, &p->filter_configs, list) {
Christopher Faulet3b386a32017-02-23 10:17:15 +01002659 struct spoe_config *conf;
2660 struct spoe_agent *agent;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002661 struct spoe_appctx *spoe_appctx;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002662
Christopher Faulet3b386a32017-02-23 10:17:15 +01002663 if (fconf->id != spoe_filter_id)
2664 continue;
2665
2666 conf = fconf->conf;
2667 agent = conf->agent;
2668
Christopher Faulet42bfa462017-01-04 14:14:19 +01002669 list_for_each_entry(spoe_appctx, &agent->applets, list) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01002670 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002671 }
2672 }
2673 p = p->next;
2674 }
2675}
2676
2677
2678/* Initialize the SPOE filter. Returns -1 on error, else 0. */
2679static int
2680spoe_init(struct proxy *px, struct flt_conf *fconf)
2681{
2682 struct spoe_config *conf = fconf->conf;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002683
2684 memset(&conf->agent_fe, 0, sizeof(conf->agent_fe));
2685 init_new_proxy(&conf->agent_fe);
2686 conf->agent_fe.parent = conf->agent;
2687 conf->agent_fe.last_change = now.tv_sec;
2688 conf->agent_fe.id = conf->agent->id;
2689 conf->agent_fe.cap = PR_CAP_FE;
2690 conf->agent_fe.mode = PR_MODE_TCP;
2691 conf->agent_fe.maxconn = 0;
2692 conf->agent_fe.options2 |= PR_O2_INDEPSTR;
2693 conf->agent_fe.conn_retries = CONN_RETRIES;
2694 conf->agent_fe.accept = frontend_accept;
2695 conf->agent_fe.srv = NULL;
2696 conf->agent_fe.timeout.client = TICK_ETERNITY;
2697 conf->agent_fe.default_target = &spoe_applet.obj_type;
2698 conf->agent_fe.fe_req_ana = AN_REQ_SWITCHING_RULES;
2699
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002700 if (!sighandler_registered) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01002701 signal_register_fct(0, spoe_sig_stop, 0);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002702 sighandler_registered = 1;
2703 }
2704
2705 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002706}
2707
2708/* Free ressources allocated by the SPOE filter. */
2709static void
2710spoe_deinit(struct proxy *px, struct flt_conf *fconf)
2711{
2712 struct spoe_config *conf = fconf->conf;
2713
2714 if (conf) {
2715 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002716
Christopher Faulet8ef75252017-02-20 22:56:03 +01002717 spoe_release_agent(agent);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002718 free(conf);
2719 }
2720 fconf->conf = NULL;
2721}
2722
2723/* Check configuration of a SPOE filter for a specified proxy.
2724 * Return 1 on error, else 0. */
2725static int
2726spoe_check(struct proxy *px, struct flt_conf *fconf)
2727{
2728 struct spoe_config *conf = fconf->conf;
2729 struct proxy *target;
2730
2731 target = proxy_be_by_name(conf->agent->b.name);
2732 if (target == NULL) {
2733 Alert("Proxy %s : unknown backend '%s' used by SPOE agent '%s'"
2734 " declared at %s:%d.\n",
2735 px->id, conf->agent->b.name, conf->agent->id,
2736 conf->agent->conf.file, conf->agent->conf.line);
2737 return 1;
2738 }
2739 if (target->mode != PR_MODE_TCP) {
2740 Alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
2741 " at %s:%d does not support HTTP mode.\n",
2742 px->id, target->id, conf->agent->id,
2743 conf->agent->conf.file, conf->agent->conf.line);
2744 return 1;
2745 }
2746
2747 free(conf->agent->b.name);
2748 conf->agent->b.name = NULL;
2749 conf->agent->b.be = target;
2750 return 0;
2751}
2752
2753/**************************************************************************
2754 * Hooks attached to a stream
2755 *************************************************************************/
2756/* Called when a filter instance is created and attach to a stream. It creates
2757 * the context that will be used to process this stream. */
2758static int
2759spoe_start(struct stream *s, struct filter *filter)
2760{
Christopher Faulet72bcc472017-01-04 16:39:41 +01002761 struct spoe_config *conf = FLT_CONF(filter);
2762 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002763 struct spoe_context *ctx;
2764
2765 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
Christopher Faulet72bcc472017-01-04 16:39:41 +01002766 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002767 __FUNCTION__, s);
2768
Christopher Faulet8ef75252017-02-20 22:56:03 +01002769 ctx = spoe_create_context(filter);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002770 if (ctx == NULL) {
Christopher Faulet72bcc472017-01-04 16:39:41 +01002771 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2772 " - failed to create SPOE context\n",
2773 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2774 __FUNCTION__, ctx->strm);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002775 send_log(s->be, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01002776 "SPOE: [%s] failed to create SPOE context\n",
2777 agent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002778 return 0;
2779 }
2780
2781 ctx->strm = s;
2782 ctx->state = SPOE_CTX_ST_READY;
2783 filter->ctx = ctx;
2784
2785 if (!LIST_ISEMPTY(&ctx->messages[SPOE_EV_ON_TCP_REQ_FE]))
2786 filter->pre_analyzers |= AN_REQ_INSPECT_FE;
2787
2788 if (!LIST_ISEMPTY(&ctx->messages[SPOE_EV_ON_TCP_REQ_BE]))
2789 filter->pre_analyzers |= AN_REQ_INSPECT_BE;
2790
2791 if (!LIST_ISEMPTY(&ctx->messages[SPOE_EV_ON_TCP_RSP]))
2792 filter->pre_analyzers |= AN_RES_INSPECT;
2793
2794 if (!LIST_ISEMPTY(&ctx->messages[SPOE_EV_ON_HTTP_REQ_FE]))
2795 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_FE;
2796
2797 if (!LIST_ISEMPTY(&ctx->messages[SPOE_EV_ON_HTTP_REQ_BE]))
2798 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_BE;
2799
2800 if (!LIST_ISEMPTY(&ctx->messages[SPOE_EV_ON_HTTP_RSP]))
2801 filter->pre_analyzers |= AN_RES_HTTP_PROCESS_FE;
2802
2803 return 1;
2804}
2805
2806/* Called when a filter instance is detached from a stream. It release the
2807 * attached SPOE context. */
2808static void
2809spoe_stop(struct stream *s, struct filter *filter)
2810{
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002811 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
2812 (int)now.tv_sec, (int)now.tv_usec,
2813 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
2814 __FUNCTION__, s);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002815 spoe_destroy_context(filter->ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002816}
2817
Christopher Fauletf7a30922016-11-10 15:04:51 +01002818
2819/*
2820 * Called when the stream is woken up because of expired timer.
2821 */
2822static void
2823spoe_check_timeouts(struct stream *s, struct filter *filter)
2824{
2825 struct spoe_context *ctx = filter->ctx;
2826
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002827 if (tick_is_expired(ctx->process_exp, now_ms)) {
2828 s->pending_events |= TASK_WOKEN_MSG;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002829 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002830 }
Christopher Fauletf7a30922016-11-10 15:04:51 +01002831}
2832
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002833/* Called when we are ready to filter data on a channel */
2834static int
2835spoe_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
2836{
2837 struct spoe_context *ctx = filter->ctx;
2838 int ret = 1;
2839
2840 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
2841 " - ctx-flags=0x%08x\n",
2842 (int)now.tv_sec, (int)now.tv_usec,
2843 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
2844 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
2845
Christopher Fauletb067b062017-01-04 16:39:11 +01002846 if (ctx->state == SPOE_CTX_ST_NONE)
2847 goto out;
2848
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002849 if (!(chn->flags & CF_ISRESP)) {
2850 if (filter->pre_analyzers & AN_REQ_INSPECT_FE)
2851 chn->analysers |= AN_REQ_INSPECT_FE;
2852 if (filter->pre_analyzers & AN_REQ_INSPECT_BE)
2853 chn->analysers |= AN_REQ_INSPECT_BE;
2854
2855 if (ctx->flags & SPOE_CTX_FL_CLI_CONNECTED)
2856 goto out;
2857
2858 ctx->stream_id = s->uniq_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002859 ret = spoe_process_event(s, ctx, SPOE_EV_ON_CLIENT_SESS);
Christopher Fauletb067b062017-01-04 16:39:11 +01002860 if (!ret)
2861 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002862 ctx->flags |= SPOE_CTX_FL_CLI_CONNECTED;
2863 }
2864 else {
2865 if (filter->pre_analyzers & SPOE_EV_ON_TCP_RSP)
2866 chn->analysers |= AN_RES_INSPECT;
2867
2868 if (ctx->flags & SPOE_CTX_FL_SRV_CONNECTED)
2869 goto out;
2870
Christopher Faulet8ef75252017-02-20 22:56:03 +01002871 ret = spoe_process_event(s, ctx, SPOE_EV_ON_SERVER_SESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002872 if (!ret) {
2873 channel_dont_read(chn);
2874 channel_dont_close(chn);
Christopher Fauletb067b062017-01-04 16:39:11 +01002875 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002876 }
Christopher Fauletb067b062017-01-04 16:39:11 +01002877 ctx->flags |= SPOE_CTX_FL_SRV_CONNECTED;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002878 }
2879
2880 out:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002881 return ret;
2882}
2883
2884/* Called before a processing happens on a given channel */
2885static int
2886spoe_chn_pre_analyze(struct stream *s, struct filter *filter,
2887 struct channel *chn, unsigned an_bit)
2888{
2889 struct spoe_context *ctx = filter->ctx;
2890 int ret = 1;
2891
2892 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
2893 " - ctx-flags=0x%08x - ana=0x%08x\n",
2894 (int)now.tv_sec, (int)now.tv_usec,
2895 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
2896 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2897 ctx->flags, an_bit);
2898
Christopher Fauletb067b062017-01-04 16:39:11 +01002899 if (ctx->state == SPOE_CTX_ST_NONE)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002900 goto out;
2901
2902 switch (an_bit) {
2903 case AN_REQ_INSPECT_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01002904 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002905 break;
2906 case AN_REQ_INSPECT_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01002907 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002908 break;
2909 case AN_RES_INSPECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01002910 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002911 break;
2912 case AN_REQ_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01002913 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002914 break;
2915 case AN_REQ_HTTP_PROCESS_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01002916 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002917 break;
2918 case AN_RES_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01002919 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002920 break;
2921 }
2922
2923 out:
2924 if (!ret) {
2925 channel_dont_read(chn);
2926 channel_dont_close(chn);
2927 }
2928 return ret;
2929}
2930
2931/* Called when the filtering on the channel ends. */
2932static int
2933spoe_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
2934{
2935 struct spoe_context *ctx = filter->ctx;
2936
2937 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
2938 " - ctx-flags=0x%08x\n",
2939 (int)now.tv_sec, (int)now.tv_usec,
2940 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
2941 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
2942
2943 if (!(ctx->flags & SPOE_CTX_FL_PROCESS)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01002944 spoe_reset_context(ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002945 }
2946
2947 return 1;
2948}
2949
2950/********************************************************************
2951 * Functions that manage the filter initialization
2952 ********************************************************************/
2953struct flt_ops spoe_ops = {
2954 /* Manage SPOE filter, called for each filter declaration */
2955 .init = spoe_init,
2956 .deinit = spoe_deinit,
2957 .check = spoe_check,
2958
2959 /* Handle start/stop of SPOE */
Christopher Fauletf7a30922016-11-10 15:04:51 +01002960 .attach = spoe_start,
2961 .detach = spoe_stop,
2962 .check_timeouts = spoe_check_timeouts,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002963
2964 /* Handle channels activity */
2965 .channel_start_analyze = spoe_start_analyze,
2966 .channel_pre_analyze = spoe_chn_pre_analyze,
2967 .channel_end_analyze = spoe_end_analyze,
2968};
2969
2970
2971static int
2972cfg_parse_spoe_agent(const char *file, int linenum, char **args, int kwm)
2973{
2974 const char *err;
2975 int i, err_code = 0;
2976
2977 if ((cfg_scope == NULL && curengine != NULL) ||
2978 (cfg_scope != NULL && curengine == NULL) ||
2979 strcmp(curengine, cfg_scope))
2980 goto out;
2981
2982 if (!strcmp(args[0], "spoe-agent")) { /* new spoe-agent section */
2983 if (!*args[1]) {
2984 Alert("parsing [%s:%d] : missing name for spoe-agent section.\n",
2985 file, linenum);
2986 err_code |= ERR_ALERT | ERR_ABORT;
2987 goto out;
2988 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01002989 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
2990 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002991 goto out;
2992 }
2993
2994 err = invalid_char(args[1]);
2995 if (err) {
2996 Alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
2997 file, linenum, *err, args[0], args[1]);
2998 err_code |= ERR_ALERT | ERR_ABORT;
2999 goto out;
3000 }
3001
3002 if (curagent != NULL) {
3003 Alert("parsing [%s:%d] : another spoe-agent section previously defined.\n",
3004 file, linenum);
3005 err_code |= ERR_ALERT | ERR_ABORT;
3006 goto out;
3007 }
3008 if ((curagent = calloc(1, sizeof(*curagent))) == NULL) {
3009 Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3010 err_code |= ERR_ALERT | ERR_ABORT;
3011 goto out;
3012 }
3013
3014 curagent->id = strdup(args[1]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003015
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003016 curagent->conf.file = strdup(file);
3017 curagent->conf.line = linenum;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003018
3019 curagent->timeout.hello = TICK_ETERNITY;
3020 curagent->timeout.idle = TICK_ETERNITY;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003021 curagent->timeout.processing = TICK_ETERNITY;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003022
3023 curagent->engine_id = NULL;
3024 curagent->var_pfx = NULL;
3025 curagent->var_on_error = NULL;
Christopher Fauletcecd8522017-02-24 22:11:21 +01003026 curagent->flags = (SPOE_FL_PIPELINING | SPOE_FL_ASYNC | SPOE_FL_SND_FRAGMENTATION);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003027 curagent->cps_max = 0;
3028 curagent->eps_max = 0;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01003029 curagent->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003030 curagent->min_applets = 0;
3031 curagent->max_fpa = 100;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003032
3033 for (i = 0; i < SPOE_EV_EVENTS; ++i)
3034 LIST_INIT(&curagent->messages[i]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003035
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01003036 curagent->frame_size = curagent->max_frame_size;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003037 curagent->applets_act = 0;
3038 curagent->applets_idle = 0;
3039 curagent->sending_rate = 0;
3040
3041 LIST_INIT(&curagent->applets);
3042 LIST_INIT(&curagent->sending_queue);
3043 LIST_INIT(&curagent->waiting_queue);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003044 }
3045 else if (!strcmp(args[0], "use-backend")) {
3046 if (!*args[1]) {
3047 Alert("parsing [%s:%d] : '%s' expects a backend name.\n",
3048 file, linenum, args[0]);
3049 err_code |= ERR_ALERT | ERR_FATAL;
3050 goto out;
3051 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003052 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003053 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003054 free(curagent->b.name);
3055 curagent->b.name = strdup(args[1]);
3056 }
3057 else if (!strcmp(args[0], "messages")) {
3058 int cur_arg = 1;
3059 while (*args[cur_arg]) {
3060 struct spoe_msg_placeholder *mp = NULL;
3061
3062 list_for_each_entry(mp, &curmps, list) {
3063 if (!strcmp(mp->id, args[cur_arg])) {
3064 Alert("parsing [%s:%d]: spoe-message message '%s' already declared.\n",
3065 file, linenum, args[cur_arg]);
3066 err_code |= ERR_ALERT | ERR_FATAL;
3067 goto out;
3068 }
3069 }
3070
3071 if ((mp = calloc(1, sizeof(*mp))) == NULL) {
3072 Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3073 err_code |= ERR_ALERT | ERR_ABORT;
3074 goto out;
3075 }
3076 mp->id = strdup(args[cur_arg]);
3077 LIST_ADDQ(&curmps, &mp->list);
3078 cur_arg++;
3079 }
3080 }
3081 else if (!strcmp(args[0], "timeout")) {
3082 unsigned int *tv = NULL;
3083 const char *res;
3084 unsigned timeout;
3085
3086 if (!*args[1]) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003087 Alert("parsing [%s:%d] : 'timeout' expects 'hello', 'idle' and 'processing'.\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003088 file, linenum);
3089 err_code |= ERR_ALERT | ERR_FATAL;
3090 goto out;
3091 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003092 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3093 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003094 if (!strcmp(args[1], "hello"))
3095 tv = &curagent->timeout.hello;
3096 else if (!strcmp(args[1], "idle"))
3097 tv = &curagent->timeout.idle;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003098 else if (!strcmp(args[1], "processing"))
3099 tv = &curagent->timeout.processing;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003100 else {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003101 Alert("parsing [%s:%d] : 'timeout' supports 'hello', 'idle' or 'processing' (got %s).\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003102 file, linenum, args[1]);
3103 err_code |= ERR_ALERT | ERR_FATAL;
3104 goto out;
3105 }
3106 if (!*args[2]) {
3107 Alert("parsing [%s:%d] : 'timeout %s' expects an integer value (in milliseconds).\n",
3108 file, linenum, args[1]);
3109 err_code |= ERR_ALERT | ERR_FATAL;
3110 goto out;
3111 }
3112 res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
3113 if (res) {
3114 Alert("parsing [%s:%d] : unexpected character '%c' in 'timeout %s'.\n",
3115 file, linenum, *res, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003116 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003117 goto out;
3118 }
3119 *tv = MS_TO_TICKS(timeout);
3120 }
3121 else if (!strcmp(args[0], "option")) {
3122 if (!*args[1]) {
3123 Alert("parsing [%s:%d]: '%s' expects an option name.\n",
3124 file, linenum, args[0]);
3125 err_code |= ERR_ALERT | ERR_FATAL;
3126 goto out;
3127 }
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003128
Christopher Faulet305c6072017-02-23 16:17:53 +01003129 if (!strcmp(args[1], "pipelining")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003130 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003131 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003132 if (kwm == 1)
3133 curagent->flags &= ~SPOE_FL_PIPELINING;
3134 else
3135 curagent->flags |= SPOE_FL_PIPELINING;
3136 goto out;
3137 }
3138 else if (!strcmp(args[1], "async")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003139 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003140 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003141 if (kwm == 1)
3142 curagent->flags &= ~SPOE_FL_ASYNC;
3143 else
3144 curagent->flags |= SPOE_FL_ASYNC;
3145 goto out;
3146 }
Christopher Fauletcecd8522017-02-24 22:11:21 +01003147 else if (!strcmp(args[1], "send-frag-payload")) {
3148 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3149 goto out;
3150 if (kwm == 1)
3151 curagent->flags &= ~SPOE_FL_SND_FRAGMENTATION;
3152 else
3153 curagent->flags |= SPOE_FL_SND_FRAGMENTATION;
3154 goto out;
3155 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003156
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003157 /* Following options does not support negation */
3158 if (kwm == 1) {
3159 Alert("parsing [%s:%d]: negation is not supported for option '%s'.\n",
3160 file, linenum, args[1]);
3161 err_code |= ERR_ALERT | ERR_FATAL;
3162 goto out;
3163 }
3164
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003165 if (!strcmp(args[1], "var-prefix")) {
3166 char *tmp;
3167
3168 if (!*args[2]) {
3169 Alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3170 file, linenum, args[0],
3171 args[1]);
3172 err_code |= ERR_ALERT | ERR_FATAL;
3173 goto out;
3174 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003175 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3176 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003177 tmp = args[2];
3178 while (*tmp) {
3179 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
3180 Alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z_-.] chars.\n",
3181 file, linenum, args[0], args[1]);
3182 err_code |= ERR_ALERT | ERR_FATAL;
3183 goto out;
3184 }
3185 tmp++;
3186 }
3187 curagent->var_pfx = strdup(args[2]);
3188 }
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003189 else if (!strcmp(args[1], "continue-on-error")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003190 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003191 goto out;
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003192 curagent->flags |= SPOE_FL_CONT_ON_ERR;
3193 }
Christopher Faulet985532d2016-11-16 15:36:19 +01003194 else if (!strcmp(args[1], "set-on-error")) {
3195 char *tmp;
3196
3197 if (!*args[2]) {
3198 Alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3199 file, linenum, args[0],
3200 args[1]);
3201 err_code |= ERR_ALERT | ERR_FATAL;
3202 goto out;
3203 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003204 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3205 goto out;
Christopher Faulet985532d2016-11-16 15:36:19 +01003206 tmp = args[2];
3207 while (*tmp) {
3208 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
3209 Alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z_-.] chars.\n",
3210 file, linenum, args[0], args[1]);
3211 err_code |= ERR_ALERT | ERR_FATAL;
3212 goto out;
3213 }
3214 tmp++;
3215 }
3216 curagent->var_on_error = strdup(args[2]);
3217 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003218 else {
3219 Alert("parsing [%s:%d]: option '%s' is not supported.\n",
3220 file, linenum, args[1]);
3221 err_code |= ERR_ALERT | ERR_FATAL;
3222 goto out;
3223 }
Christopher Faulet48026722016-11-16 15:01:12 +01003224 }
3225 else if (!strcmp(args[0], "maxconnrate")) {
3226 if (!*args[1]) {
3227 Alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3228 file, linenum, args[0]);
3229 err_code |= ERR_ALERT | ERR_FATAL;
3230 goto out;
3231 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003232 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003233 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003234 curagent->cps_max = atol(args[1]);
3235 }
3236 else if (!strcmp(args[0], "maxerrrate")) {
3237 if (!*args[1]) {
3238 Alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3239 file, linenum, args[0]);
3240 err_code |= ERR_ALERT | ERR_FATAL;
3241 goto out;
3242 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003243 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003244 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003245 curagent->eps_max = atol(args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003246 }
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003247 else if (!strcmp(args[0], "max-frame-size")) {
3248 if (!*args[1]) {
3249 Alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3250 file, linenum, args[0]);
3251 err_code |= ERR_ALERT | ERR_FATAL;
3252 goto out;
3253 }
3254 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3255 goto out;
3256 curagent->max_frame_size = atol(args[1]);
3257 if (curagent->max_frame_size < MIN_FRAME_SIZE ||
3258 curagent->max_frame_size > MAX_FRAME_SIZE) {
3259 Alert("parsing [%s:%d] : '%s' expects a positive integer argument in the range [%d, %d].\n",
3260 file, linenum, args[0], MIN_FRAME_SIZE, MAX_FRAME_SIZE);
3261 err_code |= ERR_ALERT | ERR_FATAL;
3262 goto out;
3263 }
3264 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003265 else if (*args[0]) {
3266 Alert("parsing [%s:%d] : unknown keyword '%s' in spoe-agent section.\n",
3267 file, linenum, args[0]);
3268 err_code |= ERR_ALERT | ERR_FATAL;
3269 goto out;
3270 }
3271 out:
3272 return err_code;
3273}
3274
3275static int
3276cfg_parse_spoe_message(const char *file, int linenum, char **args, int kwm)
3277{
3278 struct spoe_message *msg;
3279 struct spoe_arg *arg;
3280 const char *err;
3281 char *errmsg = NULL;
3282 int err_code = 0;
3283
3284 if ((cfg_scope == NULL && curengine != NULL) ||
3285 (cfg_scope != NULL && curengine == NULL) ||
3286 strcmp(curengine, cfg_scope))
3287 goto out;
3288
3289 if (!strcmp(args[0], "spoe-message")) { /* new spoe-message section */
3290 if (!*args[1]) {
3291 Alert("parsing [%s:%d] : missing name for spoe-message section.\n",
3292 file, linenum);
3293 err_code |= ERR_ALERT | ERR_ABORT;
3294 goto out;
3295 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003296 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3297 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003298 goto out;
3299 }
3300
3301 err = invalid_char(args[1]);
3302 if (err) {
3303 Alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3304 file, linenum, *err, args[0], args[1]);
3305 err_code |= ERR_ALERT | ERR_ABORT;
3306 goto out;
3307 }
3308
3309 list_for_each_entry(msg, &curmsgs, list) {
3310 if (!strcmp(msg->id, args[1])) {
3311 Alert("parsing [%s:%d]: spoe-message section '%s' has the same"
3312 " name as another one declared at %s:%d.\n",
3313 file, linenum, args[1], msg->conf.file, msg->conf.line);
3314 err_code |= ERR_ALERT | ERR_FATAL;
3315 goto out;
3316 }
3317 }
3318
3319 if ((curmsg = calloc(1, sizeof(*curmsg))) == NULL) {
3320 Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3321 err_code |= ERR_ALERT | ERR_ABORT;
3322 goto out;
3323 }
3324
3325 curmsg->id = strdup(args[1]);
3326 curmsg->id_len = strlen(curmsg->id);
3327 curmsg->event = SPOE_EV_NONE;
3328 curmsg->conf.file = strdup(file);
3329 curmsg->conf.line = linenum;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003330 curmsg->nargs = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003331 LIST_INIT(&curmsg->args);
3332 LIST_ADDQ(&curmsgs, &curmsg->list);
3333 }
3334 else if (!strcmp(args[0], "args")) {
3335 int cur_arg = 1;
3336
3337 curproxy->conf.args.ctx = ARGC_SPOE;
3338 curproxy->conf.args.file = file;
3339 curproxy->conf.args.line = linenum;
3340 while (*args[cur_arg]) {
3341 char *delim = strchr(args[cur_arg], '=');
3342 int idx = 0;
3343
3344 if ((arg = calloc(1, sizeof(*arg))) == NULL) {
3345 Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3346 err_code |= ERR_ALERT | ERR_ABORT;
3347 goto out;
3348 }
3349
3350 if (!delim) {
3351 arg->name = NULL;
3352 arg->name_len = 0;
3353 delim = args[cur_arg];
3354 }
3355 else {
3356 arg->name = my_strndup(args[cur_arg], delim - args[cur_arg]);
3357 arg->name_len = delim - args[cur_arg];
3358 delim++;
3359 }
Christopher Fauletb0b42382017-02-23 22:41:09 +01003360 arg->expr = sample_parse_expr((char*[]){delim, NULL},
3361 &idx, file, linenum, &errmsg,
3362 &curproxy->conf.args);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003363 if (arg->expr == NULL) {
3364 Alert("parsing [%s:%d] : '%s': %s.\n", file, linenum, args[0], errmsg);
3365 err_code |= ERR_ALERT | ERR_FATAL;
3366 free(arg->name);
3367 free(arg);
3368 goto out;
3369 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003370 curmsg->nargs++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003371 LIST_ADDQ(&curmsg->args, &arg->list);
3372 cur_arg++;
3373 }
3374 curproxy->conf.args.file = NULL;
3375 curproxy->conf.args.line = 0;
3376 }
3377 else if (!strcmp(args[0], "event")) {
3378 if (!*args[1]) {
3379 Alert("parsing [%s:%d] : missing event name.\n", file, linenum);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003380 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003381 goto out;
3382 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003383 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3384 goto out;
3385
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003386 if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_CLIENT_SESS]))
3387 curmsg->event = SPOE_EV_ON_CLIENT_SESS;
3388 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_SERVER_SESS]))
3389 curmsg->event = SPOE_EV_ON_SERVER_SESS;
3390
3391 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_FE]))
3392 curmsg->event = SPOE_EV_ON_TCP_REQ_FE;
3393 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_BE]))
3394 curmsg->event = SPOE_EV_ON_TCP_REQ_BE;
3395 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_RSP]))
3396 curmsg->event = SPOE_EV_ON_TCP_RSP;
3397
3398 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_FE]))
3399 curmsg->event = SPOE_EV_ON_HTTP_REQ_FE;
3400 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_BE]))
3401 curmsg->event = SPOE_EV_ON_HTTP_REQ_BE;
3402 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_RSP]))
3403 curmsg->event = SPOE_EV_ON_HTTP_RSP;
3404 else {
3405 Alert("parsing [%s:%d] : unkown event '%s'.\n",
3406 file, linenum, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003407 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003408 goto out;
3409 }
3410 }
3411 else if (!*args[0]) {
3412 Alert("parsing [%s:%d] : unknown keyword '%s' in spoe-message section.\n",
3413 file, linenum, args[0]);
3414 err_code |= ERR_ALERT | ERR_FATAL;
3415 goto out;
3416 }
3417 out:
3418 free(errmsg);
3419 return err_code;
3420}
3421
3422/* Return -1 on error, else 0 */
3423static int
3424parse_spoe_flt(char **args, int *cur_arg, struct proxy *px,
3425 struct flt_conf *fconf, char **err, void *private)
3426{
3427 struct list backup_sections;
3428 struct spoe_config *conf;
3429 struct spoe_message *msg, *msgback;
3430 struct spoe_msg_placeholder *mp, *mpback;
3431 char *file = NULL, *engine = NULL;
3432 int ret, pos = *cur_arg + 1;
3433
3434 conf = calloc(1, sizeof(*conf));
3435 if (conf == NULL) {
3436 memprintf(err, "%s: out of memory", args[*cur_arg]);
3437 goto error;
3438 }
3439 conf->proxy = px;
3440
3441 while (*args[pos]) {
3442 if (!strcmp(args[pos], "config")) {
3443 if (!*args[pos+1]) {
3444 memprintf(err, "'%s' : '%s' option without value",
3445 args[*cur_arg], args[pos]);
3446 goto error;
3447 }
3448 file = args[pos+1];
3449 pos += 2;
3450 }
3451 else if (!strcmp(args[pos], "engine")) {
3452 if (!*args[pos+1]) {
3453 memprintf(err, "'%s' : '%s' option without value",
3454 args[*cur_arg], args[pos]);
3455 goto error;
3456 }
3457 engine = args[pos+1];
3458 pos += 2;
3459 }
3460 else {
3461 memprintf(err, "unknown keyword '%s'", args[pos]);
3462 goto error;
3463 }
3464 }
3465 if (file == NULL) {
3466 memprintf(err, "'%s' : missing config file", args[*cur_arg]);
3467 goto error;
3468 }
3469
3470 /* backup sections and register SPOE sections */
3471 LIST_INIT(&backup_sections);
3472 cfg_backup_sections(&backup_sections);
3473 cfg_register_section("spoe-agent", cfg_parse_spoe_agent);
3474 cfg_register_section("spoe-message", cfg_parse_spoe_message);
3475
3476 /* Parse SPOE filter configuration file */
3477 curengine = engine;
3478 curproxy = px;
3479 curagent = NULL;
3480 curmsg = NULL;
3481 ret = readcfgfile(file);
3482 curproxy = NULL;
3483
3484 /* unregister SPOE sections and restore previous sections */
3485 cfg_unregister_sections();
3486 cfg_restore_sections(&backup_sections);
3487
3488 if (ret == -1) {
3489 memprintf(err, "Could not open configuration file %s : %s",
3490 file, strerror(errno));
3491 goto error;
3492 }
3493 if (ret & (ERR_ABORT|ERR_FATAL)) {
3494 memprintf(err, "Error(s) found in configuration file %s", file);
3495 goto error;
3496 }
3497
3498 /* Check SPOE agent */
3499 if (curagent == NULL) {
3500 memprintf(err, "No SPOE agent found in file %s", file);
3501 goto error;
3502 }
3503 if (curagent->b.name == NULL) {
3504 memprintf(err, "No backend declared for SPOE agent '%s' declared at %s:%d",
3505 curagent->id, curagent->conf.file, curagent->conf.line);
3506 goto error;
3507 }
Christopher Fauletf7a30922016-11-10 15:04:51 +01003508 if (curagent->timeout.hello == TICK_ETERNITY ||
3509 curagent->timeout.idle == TICK_ETERNITY ||
Christopher Fauletf7a30922016-11-10 15:04:51 +01003510 curagent->timeout.processing == TICK_ETERNITY) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003511 Warning("Proxy '%s': missing timeouts for SPOE agent '%s' declare at %s:%d.\n"
3512 " | While not properly invalid, you will certainly encounter various problems\n"
3513 " | with such a configuration. To fix this, please ensure that all following\n"
Christopher Faulet03a34492016-11-19 16:47:56 +01003514 " | timeouts are set to a non-zero value: 'hello', 'idle', 'processing'.\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003515 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
3516 }
3517 if (curagent->var_pfx == NULL) {
3518 char *tmp = curagent->id;
3519
3520 while (*tmp) {
3521 if (!isalnum(*tmp) && *tmp != '_' && *tmp != '.') {
3522 memprintf(err, "Invalid variable prefix '%s' for SPOE agent '%s' declared at %s:%d. "
3523 "Use 'option var-prefix' to set it. Only [a-zA-Z0-9_.] chars are supported.\n",
3524 curagent->id, curagent->id, curagent->conf.file, curagent->conf.line);
3525 goto error;
3526 }
3527 tmp++;
3528 }
3529 curagent->var_pfx = strdup(curagent->id);
3530 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01003531 if (curagent->engine_id == NULL)
3532 curagent->engine_id = generate_pseudo_uuid();
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003533
3534 if (LIST_ISEMPTY(&curmps)) {
3535 Warning("Proxy '%s': No message used by SPOE agent '%s' declared at %s:%d.\n",
3536 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
3537 goto finish;
3538 }
3539
3540 list_for_each_entry_safe(mp, mpback, &curmps, list) {
3541 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
Christopher Fauleta21b0642017-01-09 16:56:23 +01003542 struct spoe_arg *arg;
3543 unsigned int where;
3544
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003545 if (!strcmp(msg->id, mp->id)) {
3546 if ((px->cap & (PR_CAP_FE|PR_CAP_BE)) == (PR_CAP_FE|PR_CAP_BE)) {
3547 if (msg->event == SPOE_EV_ON_TCP_REQ_BE)
3548 msg->event = SPOE_EV_ON_TCP_REQ_FE;
3549 if (msg->event == SPOE_EV_ON_HTTP_REQ_BE)
3550 msg->event = SPOE_EV_ON_HTTP_REQ_FE;
3551 }
3552 if (!(px->cap & PR_CAP_FE) && (msg->event == SPOE_EV_ON_CLIENT_SESS ||
3553 msg->event == SPOE_EV_ON_TCP_REQ_FE ||
3554 msg->event == SPOE_EV_ON_HTTP_REQ_FE)) {
3555 Warning("Proxy '%s': frontend event used on a backend proxy at %s:%d.\n",
3556 px->id, msg->conf.file, msg->conf.line);
3557 goto next;
3558 }
3559 if (msg->event == SPOE_EV_NONE) {
3560 Warning("Proxy '%s': Ignore SPOE message without event at %s:%d.\n",
3561 px->id, msg->conf.file, msg->conf.line);
3562 goto next;
3563 }
Christopher Fauleta21b0642017-01-09 16:56:23 +01003564
3565 where = 0;
3566 switch (msg->event) {
3567 case SPOE_EV_ON_CLIENT_SESS:
3568 where |= SMP_VAL_FE_CON_ACC;
3569 break;
3570
3571 case SPOE_EV_ON_TCP_REQ_FE:
3572 where |= SMP_VAL_FE_REQ_CNT;
3573 break;
3574
3575 case SPOE_EV_ON_HTTP_REQ_FE:
3576 where |= SMP_VAL_FE_HRQ_HDR;
3577 break;
3578
3579 case SPOE_EV_ON_TCP_REQ_BE:
3580 if (px->cap & PR_CAP_FE)
3581 where |= SMP_VAL_FE_REQ_CNT;
3582 if (px->cap & PR_CAP_BE)
3583 where |= SMP_VAL_BE_REQ_CNT;
3584 break;
3585
3586 case SPOE_EV_ON_HTTP_REQ_BE:
3587 if (px->cap & PR_CAP_FE)
3588 where |= SMP_VAL_FE_HRQ_HDR;
3589 if (px->cap & PR_CAP_BE)
3590 where |= SMP_VAL_BE_HRQ_HDR;
3591 break;
3592
3593 case SPOE_EV_ON_SERVER_SESS:
3594 where |= SMP_VAL_BE_SRV_CON;
3595 break;
3596
3597 case SPOE_EV_ON_TCP_RSP:
3598 if (px->cap & PR_CAP_FE)
3599 where |= SMP_VAL_FE_RES_CNT;
3600 if (px->cap & PR_CAP_BE)
3601 where |= SMP_VAL_BE_RES_CNT;
3602 break;
3603
3604 case SPOE_EV_ON_HTTP_RSP:
3605 if (px->cap & PR_CAP_FE)
3606 where |= SMP_VAL_FE_HRS_HDR;
3607 if (px->cap & PR_CAP_BE)
3608 where |= SMP_VAL_BE_HRS_HDR;
3609 break;
3610
3611 default:
3612 break;
3613 }
3614
3615 list_for_each_entry(arg, &msg->args, list) {
3616 if (!(arg->expr->fetch->val & where)) {
3617 Warning("Proxy '%s': Ignore SPOE message at %s:%d: "
3618 "some args extract information from '%s', "
3619 "none of which is available here ('%s').\n",
3620 px->id, msg->conf.file, msg->conf.line,
3621 sample_ckp_names(arg->expr->fetch->use),
3622 sample_ckp_names(where));
3623 goto next;
3624 }
3625 }
3626
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003627 msg->agent = curagent;
3628 LIST_DEL(&msg->list);
3629 LIST_ADDQ(&curagent->messages[msg->event], &msg->list);
3630 goto next;
3631 }
3632 }
3633 memprintf(err, "SPOE agent '%s' try to use undefined SPOE message '%s' at %s:%d",
3634 curagent->id, mp->id, curagent->conf.file, curagent->conf.line);
3635 goto error;
3636 next:
3637 continue;
3638 }
3639
3640 finish:
3641 conf->agent = curagent;
3642 list_for_each_entry_safe(mp, mpback, &curmps, list) {
3643 LIST_DEL(&mp->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01003644 spoe_release_msg_placeholder(mp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003645 }
3646 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
3647 Warning("Proxy '%s': Ignore unused SPOE messages '%s' declared at %s:%d.\n",
3648 px->id, msg->id, msg->conf.file, msg->conf.line);
3649 LIST_DEL(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01003650 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003651 }
3652
3653 *cur_arg = pos;
Christopher Faulet3b386a32017-02-23 10:17:15 +01003654 fconf->id = spoe_filter_id;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003655 fconf->ops = &spoe_ops;
3656 fconf->conf = conf;
3657 return 0;
3658
3659 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003660 spoe_release_agent(curagent);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003661 list_for_each_entry_safe(mp, mpback, &curmps, list) {
3662 LIST_DEL(&mp->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01003663 spoe_release_msg_placeholder(mp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003664 }
3665 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
3666 LIST_DEL(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01003667 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003668 }
3669 free(conf);
3670 return -1;
3671}
3672
3673
3674/* Declare the filter parser for "spoe" keyword */
3675static struct flt_kw_list flt_kws = { "SPOE", { }, {
3676 { "spoe", parse_spoe_flt, NULL },
3677 { NULL, NULL, NULL },
3678 }
3679};
3680
3681__attribute__((constructor))
3682static void __spoe_init(void)
3683{
3684 flt_register_keywords(&flt_kws);
3685
3686 LIST_INIT(&curmsgs);
3687 LIST_INIT(&curmps);
3688 pool2_spoe_ctx = create_pool("spoe_ctx", sizeof(struct spoe_context), MEM_F_SHARED);
Christopher Faulet42bfa462017-01-04 14:14:19 +01003689 pool2_spoe_appctx = create_pool("spoe_appctx", sizeof(struct spoe_appctx), MEM_F_SHARED);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003690}
3691
3692__attribute__((destructor))
3693static void
3694__spoe_deinit(void)
3695{
3696 pool_destroy2(pool2_spoe_ctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01003697 pool_destroy2(pool2_spoe_appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003698}