blob: 58a7e7903c66835fb76fd9bfab2c1c1213bc29e4 [file] [log] [blame]
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001/*
2 * Stream processing offload engine management.
3 *
4 * Copyright 2016 HAProxy Technologies, Christopher Faulet <cfaulet@haproxy.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12#include <ctype.h>
13#include <errno.h>
14
Willy Tarreaudcc048a2020-06-04 19:11:43 +020015#include <haproxy/acl.h>
Willy Tarreau122eba92020-06-04 10:15:32 +020016#include <haproxy/action-t.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020017#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020018#include <haproxy/arg.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020019#include <haproxy/cfgparse.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020020#include <haproxy/filters.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020021#include <haproxy/freq_ctr.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020022#include <haproxy/frontend.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020023#include <haproxy/global.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020024#include <haproxy/http_rules.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020025#include <haproxy/log.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020026#include <haproxy/pool.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020027#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020028#include <haproxy/sample.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020029#include <haproxy/session.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020030#include <haproxy/signal.h>
Willy Tarreau6c58ab02020-06-04 22:35:49 +020031#include <haproxy/spoe.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020032#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020033#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020034#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020035#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020036#include <haproxy/thread.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020037#include <haproxy/time.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020038#include <haproxy/vars.h>
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020039
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020040
41#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
42#define SPOE_PRINTF(x...) fprintf(x)
Christopher Fauletb077cdc2018-01-24 16:37:57 +010043#define SPOE_DEBUG_STMT(statement) statement
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020044#else
45#define SPOE_PRINTF(x...)
Christopher Fauletb077cdc2018-01-24 16:37:57 +010046#define SPOE_DEBUG_STMT(statement)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020047#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 */
Christopher Faulet11610f32017-09-21 10:23:10 +020076/* SPOE agent/group/message used during the parsing */
77struct spoe_agent *curagent = NULL;
78struct spoe_group *curgrp = NULL;
79struct spoe_message *curmsg = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020080
81/* list of SPOE messages and placeholders used during the parsing */
82struct list curmsgs;
Christopher Faulet11610f32017-09-21 10:23:10 +020083struct list curgrps;
84struct list curmphs;
85struct list curgphs;
Christopher Faulet336d3ef2017-12-22 10:00:55 +010086struct list curvars;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020087
Christopher Faulet7250b8f2018-03-26 17:19:01 +020088/* list of log servers used during the parsing */
89struct list curlogsrvs;
90
Christopher Faulet0e0f0852018-03-26 17:20:36 +020091/* agent's proxy flags (PR_O_* and PR_O2_*) used during parsing */
92int curpxopts;
93int curpxopts2;
94
Christopher Faulet42bfa462017-01-04 14:14:19 +010095/* Pools used to allocate SPOE structs */
Willy Tarreau8ceae722018-11-26 11:58:30 +010096DECLARE_STATIC_POOL(pool_head_spoe_ctx, "spoe_ctx", sizeof(struct spoe_context));
97DECLARE_STATIC_POOL(pool_head_spoe_appctx, "spoe_appctx", sizeof(struct spoe_appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020098
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +020099struct flt_ops spoe_ops;
100
Christopher Faulet8ef75252017-02-20 22:56:03 +0100101static int spoe_queue_context(struct spoe_context *ctx);
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200102static int spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait);
103static void spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200104
105/********************************************************************
106 * helper functions/globals
107 ********************************************************************/
108static void
Christopher Faulet11610f32017-09-21 10:23:10 +0200109spoe_release_placeholder(struct spoe_placeholder *ph)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200110{
Christopher Faulet11610f32017-09-21 10:23:10 +0200111 if (!ph)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200112 return;
Christopher Faulet11610f32017-09-21 10:23:10 +0200113 free(ph->id);
114 free(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200115}
116
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200117static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100118spoe_release_message(struct spoe_message *msg)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200119{
Christopher Faulet57583e42017-09-04 15:41:09 +0200120 struct spoe_arg *arg, *argback;
121 struct acl *acl, *aclback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200122
123 if (!msg)
124 return;
125 free(msg->id);
126 free(msg->conf.file);
Christopher Faulet57583e42017-09-04 15:41:09 +0200127 list_for_each_entry_safe(arg, argback, &msg->args, list) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200128 release_sample_expr(arg->expr);
129 free(arg->name);
130 LIST_DEL(&arg->list);
131 free(arg);
132 }
Christopher Faulet57583e42017-09-04 15:41:09 +0200133 list_for_each_entry_safe(acl, aclback, &msg->acls, list) {
134 LIST_DEL(&acl->list);
135 prune_acl(acl);
136 free(acl);
137 }
138 if (msg->cond) {
139 prune_acl_cond(msg->cond);
140 free(msg->cond);
141 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200142 free(msg);
143}
144
145static void
Christopher Faulet11610f32017-09-21 10:23:10 +0200146spoe_release_group(struct spoe_group *grp)
147{
148 if (!grp)
149 return;
150 free(grp->id);
151 free(grp->conf.file);
152 free(grp);
153}
154
155static void
Christopher Faulet8ef75252017-02-20 22:56:03 +0100156spoe_release_agent(struct spoe_agent *agent)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200157{
Christopher Faulet11610f32017-09-21 10:23:10 +0200158 struct spoe_message *msg, *msgback;
159 struct spoe_group *grp, *grpback;
Christopher Faulet24289f22017-09-25 14:48:02 +0200160 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200161
162 if (!agent)
163 return;
164 free(agent->id);
165 free(agent->conf.file);
166 free(agent->var_pfx);
Christopher Faulet985532d2016-11-16 15:36:19 +0100167 free(agent->var_on_error);
Christopher Faulet36bda1c2018-03-22 09:08:20 +0100168 free(agent->var_t_process);
169 free(agent->var_t_total);
Christopher Faulet11610f32017-09-21 10:23:10 +0200170 list_for_each_entry_safe(msg, msgback, &agent->messages, list) {
171 LIST_DEL(&msg->list);
172 spoe_release_message(msg);
173 }
174 list_for_each_entry_safe(grp, grpback, &agent->groups, list) {
175 LIST_DEL(&grp->list);
176 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200177 }
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100178 if (agent->rt) {
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200179 for (i = 0; i < global.nbthread; ++i) {
180 free(agent->rt[i].engine_id);
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100181 HA_SPIN_DESTROY(&agent->rt[i].lock);
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200182 }
Willy Tarreau3ddcf762019-02-07 14:22:52 +0100183 }
Christopher Faulet24289f22017-09-25 14:48:02 +0200184 free(agent->rt);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200185 free(agent);
186}
187
188static const char *spoe_frm_err_reasons[SPOE_FRM_ERRS] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100189 [SPOE_FRM_ERR_NONE] = "normal",
190 [SPOE_FRM_ERR_IO] = "I/O error",
191 [SPOE_FRM_ERR_TOUT] = "a timeout occurred",
192 [SPOE_FRM_ERR_TOO_BIG] = "frame is too big",
193 [SPOE_FRM_ERR_INVALID] = "invalid frame received",
194 [SPOE_FRM_ERR_NO_VSN] = "version value not found",
195 [SPOE_FRM_ERR_NO_FRAME_SIZE] = "max-frame-size value not found",
196 [SPOE_FRM_ERR_NO_CAP] = "capabilities value not found",
197 [SPOE_FRM_ERR_BAD_VSN] = "unsupported version",
198 [SPOE_FRM_ERR_BAD_FRAME_SIZE] = "max-frame-size too big or too small",
199 [SPOE_FRM_ERR_FRAG_NOT_SUPPORTED] = "fragmentation not supported",
200 [SPOE_FRM_ERR_INTERLACED_FRAMES] = "invalid interlaced frames",
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100201 [SPOE_FRM_ERR_FRAMEID_NOTFOUND] = "frame-id not found",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100202 [SPOE_FRM_ERR_RES] = "resource allocation error",
203 [SPOE_FRM_ERR_UNKNOWN] = "an unknown error occurred",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200204};
205
206static const char *spoe_event_str[SPOE_EV_EVENTS] = {
207 [SPOE_EV_ON_CLIENT_SESS] = "on-client-session",
208 [SPOE_EV_ON_TCP_REQ_FE] = "on-frontend-tcp-request",
209 [SPOE_EV_ON_TCP_REQ_BE] = "on-backend-tcp-request",
210 [SPOE_EV_ON_HTTP_REQ_FE] = "on-frontend-http-request",
211 [SPOE_EV_ON_HTTP_REQ_BE] = "on-backend-http-request",
212
213 [SPOE_EV_ON_SERVER_SESS] = "on-server-session",
214 [SPOE_EV_ON_TCP_RSP] = "on-tcp-response",
215 [SPOE_EV_ON_HTTP_RSP] = "on-http-response",
216};
217
218
219#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
220
221static const char *spoe_ctx_state_str[SPOE_CTX_ST_ERROR+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100222 [SPOE_CTX_ST_NONE] = "NONE",
223 [SPOE_CTX_ST_READY] = "READY",
224 [SPOE_CTX_ST_ENCODING_MSGS] = "ENCODING_MSGS",
225 [SPOE_CTX_ST_SENDING_MSGS] = "SENDING_MSGS",
226 [SPOE_CTX_ST_WAITING_ACK] = "WAITING_ACK",
227 [SPOE_CTX_ST_DONE] = "DONE",
228 [SPOE_CTX_ST_ERROR] = "ERROR",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200229};
230
231static const char *spoe_appctx_state_str[SPOE_APPCTX_ST_END+1] = {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100232 [SPOE_APPCTX_ST_CONNECT] = "CONNECT",
233 [SPOE_APPCTX_ST_CONNECTING] = "CONNECTING",
234 [SPOE_APPCTX_ST_IDLE] = "IDLE",
235 [SPOE_APPCTX_ST_PROCESSING] = "PROCESSING",
236 [SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY] = "SENDING_FRAG_NOTIFY",
237 [SPOE_APPCTX_ST_WAITING_SYNC_ACK] = "WAITING_SYNC_ACK",
238 [SPOE_APPCTX_ST_DISCONNECT] = "DISCONNECT",
239 [SPOE_APPCTX_ST_DISCONNECTING] = "DISCONNECTING",
240 [SPOE_APPCTX_ST_EXIT] = "EXIT",
241 [SPOE_APPCTX_ST_END] = "END",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200242};
243
244#endif
Christopher Fauleta1cda022016-12-21 08:58:06 +0100245
Christopher Faulet8ef75252017-02-20 22:56:03 +0100246/* Used to generates a unique id for an engine. On success, it returns a
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500247 * allocated string. So it is the caller's responsibility to release it. If the
Christopher Faulet8ef75252017-02-20 22:56:03 +0100248 * allocation failed, it returns NULL. */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100249static char *
250generate_pseudo_uuid()
251{
Willy Tarreauee3bcdd2020-03-08 17:48:17 +0100252 ha_generate_uuid(&trash);
Kevin Zhu079f8082020-03-13 10:39:51 +0800253 return my_strndup(trash.area, trash.data);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100254}
255
Christopher Fauletb2dd1e02018-03-22 09:07:41 +0100256
257static inline void
258spoe_update_stat_time(struct timeval *tv, long *t)
259{
260 if (*t == -1)
261 *t = tv_ms_elapsed(tv, &now);
262 else
263 *t += tv_ms_elapsed(tv, &now);
264 tv_zero(tv);
265}
266
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200267/********************************************************************
268 * Functions that encode/decode SPOE frames
269 ********************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200270/* Helper to get static string length, excluding the terminating null byte */
271#define SLEN(str) (sizeof(str)-1)
272
273/* Predefined key used in HELLO/DISCONNECT frames */
274#define SUPPORTED_VERSIONS_KEY "supported-versions"
275#define VERSION_KEY "version"
276#define MAX_FRAME_SIZE_KEY "max-frame-size"
277#define CAPABILITIES_KEY "capabilities"
Christopher Fauleta1cda022016-12-21 08:58:06 +0100278#define ENGINE_ID_KEY "engine-id"
Christopher Fauletba7bc162016-11-07 21:07:38 +0100279#define HEALTHCHECK_KEY "healthcheck"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200280#define STATUS_CODE_KEY "status-code"
281#define MSG_KEY "message"
282
283struct spoe_version {
284 char *str;
285 int min;
286 int max;
287};
288
289/* All supported versions */
290static struct spoe_version supported_versions[] = {
Christopher Faulet63816502018-05-31 14:56:42 +0200291 /* 1.0 is now unsupported because of a bug about frame's flags*/
292 {"2.0", 2000, 2000},
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200293 {NULL, 0, 0}
294};
295
296/* Comma-separated list of supported versions */
Christopher Faulet63816502018-05-31 14:56:42 +0200297#define SUPPORTED_VERSIONS_VAL "2.0"
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200298
Christopher Faulet8ef75252017-02-20 22:56:03 +0100299/* Convert a string to a SPOE version value. The string must follow the format
300 * "MAJOR.MINOR". It will be concerted into the integer (1000 * MAJOR + MINOR).
301 * If an error occurred, -1 is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200302static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100303spoe_str_to_vsn(const char *str, size_t len)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200304{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100305 const char *p, *end;
306 int maj, min, vsn;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200307
Christopher Faulet8ef75252017-02-20 22:56:03 +0100308 p = str;
309 end = str+len;
310 maj = min = 0;
311 vsn = -1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200312
Christopher Faulet8ef75252017-02-20 22:56:03 +0100313 /* skip leading spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100314 while (p < end && isspace((unsigned char)*p))
Christopher Faulet8ef75252017-02-20 22:56:03 +0100315 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200316
Christopher Faulet8ef75252017-02-20 22:56:03 +0100317 /* parse Major number, until the '.' */
318 while (*p != '.') {
319 if (p >= end || *p < '0' || *p > '9')
320 goto out;
321 maj *= 10;
322 maj += (*p - '0');
323 p++;
324 }
325
326 /* check Major version */
327 if (!maj)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200328 goto out;
329
Christopher Faulet8ef75252017-02-20 22:56:03 +0100330 p++; /* skip the '.' */
331 if (p >= end || *p < '0' || *p > '9') /* Minor number is missing */
332 goto out;
333
334 /* Parse Minor number */
335 while (p < end) {
336 if (*p < '0' || *p > '9')
337 break;
338 min *= 10;
339 min += (*p - '0');
340 p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200341 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100342
343 /* check Minor number */
344 if (min > 999)
345 goto out;
346
347 /* skip trailing spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100348 while (p < end && isspace((unsigned char)*p))
Christopher Faulet8ef75252017-02-20 22:56:03 +0100349 p++;
350 if (p != end)
351 goto out;
352
353 vsn = maj * 1000 + min;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200354 out:
355 return vsn;
356}
357
Christopher Faulet8ef75252017-02-20 22:56:03 +0100358/* Encode the HELLO frame sent by HAProxy to an agent. It returns the number of
Joseph Herlantf7f60312018-11-15 13:46:49 -0800359 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
Christopher Faulet8ef75252017-02-20 22:56:03 +0100360 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200361static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100362spoe_prepare_hahello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200363{
Willy Tarreau83061a82018-07-13 11:56:34 +0200364 struct buffer *chk;
Christopher Faulet42bfa462017-01-04 14:14:19 +0100365 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100366 char *p, *end;
367 unsigned int flags = SPOE_FRM_FL_FIN;
368 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200369
Christopher Faulet8ef75252017-02-20 22:56:03 +0100370 p = frame;
371 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200372
Christopher Faulet8ef75252017-02-20 22:56:03 +0100373 /* Set Frame type */
374 *p++ = SPOE_FRM_T_HAPROXY_HELLO;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200375
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100376 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200377 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100378 memcpy(p, (char *)&flags, 4);
379 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200380
381 /* No stream-id and frame-id for HELLO frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100382 *p++ = 0; *p++ = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200383
384 /* There are 3 mandatory items: "supported-versions", "max-frame-size"
385 * and "capabilities" */
386
387 /* "supported-versions" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100388 sz = SLEN(SUPPORTED_VERSIONS_KEY);
389 if (spoe_encode_buffer(SUPPORTED_VERSIONS_KEY, sz, &p, end) == -1)
390 goto too_big;
391
392 *p++ = SPOE_DATA_T_STR;
393 sz = SLEN(SUPPORTED_VERSIONS_VAL);
394 if (spoe_encode_buffer(SUPPORTED_VERSIONS_VAL, sz, &p, end) == -1)
395 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200396
397 /* "max-fram-size" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100398 sz = SLEN(MAX_FRAME_SIZE_KEY);
399 if (spoe_encode_buffer(MAX_FRAME_SIZE_KEY, sz, &p, end) == -1)
400 goto too_big;
401
402 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200403 if (encode_varint(SPOE_APPCTX(appctx)->max_frame_size, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100404 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200405
406 /* "capabilities" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100407 sz = SLEN(CAPABILITIES_KEY);
408 if (spoe_encode_buffer(CAPABILITIES_KEY, sz, &p, end) == -1)
409 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200410
Christopher Faulet8ef75252017-02-20 22:56:03 +0100411 *p++ = SPOE_DATA_T_STR;
Christopher Faulet305c6072017-02-23 16:17:53 +0100412 chk = get_trash_chunk();
413 if (agent != NULL && (agent->flags & SPOE_FL_PIPELINING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200414 memcpy(chk->area, "pipelining", 10);
415 chk->data += 10;
Christopher Faulet305c6072017-02-23 16:17:53 +0100416 }
417 if (agent != NULL && (agent->flags & SPOE_FL_ASYNC)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200418 if (chk->data) chk->area[chk->data++] = ',';
419 memcpy(chk->area+chk->data, "async", 5);
420 chk->data += 5;
Christopher Faulet305c6072017-02-23 16:17:53 +0100421 }
Christopher Fauletcecd8522017-02-24 22:11:21 +0100422 if (agent != NULL && (agent->flags & SPOE_FL_RCV_FRAGMENTATION)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200423 if (chk->data) chk->area[chk->data++] = ',';
424 memcpy(chk->area+chk->data, "fragmentation", 13);
Miroslav Zagorac6b3690b2019-01-13 16:55:01 +0100425 chk->data += 13;
Christopher Fauletcecd8522017-02-24 22:11:21 +0100426 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200427 if (spoe_encode_buffer(chk->area, chk->data, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100428 goto too_big;
429
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500430 /* (optional) "engine-id" K/V item, if present */
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200431 if (agent != NULL && agent->rt[tid].engine_id != NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100432 sz = SLEN(ENGINE_ID_KEY);
433 if (spoe_encode_buffer(ENGINE_ID_KEY, sz, &p, end) == -1)
434 goto too_big;
435
436 *p++ = SPOE_DATA_T_STR;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +0200437 sz = strlen(agent->rt[tid].engine_id);
438 if (spoe_encode_buffer(agent->rt[tid].engine_id, sz, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100439 goto too_big;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100440 }
441
Christopher Faulet8ef75252017-02-20 22:56:03 +0100442 return (p - frame);
443
444 too_big:
445 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
446 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200447}
448
Christopher Faulet8ef75252017-02-20 22:56:03 +0100449/* Encode DISCONNECT frame sent by HAProxy to an agent. It returns the number of
450 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
451 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200452static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100453spoe_prepare_hadiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200454{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100455 const char *reason;
456 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100457 unsigned int flags = SPOE_FRM_FL_FIN;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100458 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200459
Christopher Faulet8ef75252017-02-20 22:56:03 +0100460 p = frame;
461 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200462
Christopher Faulet8ef75252017-02-20 22:56:03 +0100463 /* Set Frame type */
464 *p++ = SPOE_FRM_T_HAPROXY_DISCON;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200465
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100466 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200467 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100468 memcpy(p, (char *)&flags, 4);
469 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200470
471 /* No stream-id and frame-id for DISCONNECT frames */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100472 *p++ = 0; *p++ = 0;
473
474 if (SPOE_APPCTX(appctx)->status_code >= SPOE_FRM_ERRS)
475 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200476
477 /* There are 2 mandatory items: "status-code" and "message" */
478
479 /* "status-code" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100480 sz = SLEN(STATUS_CODE_KEY);
481 if (spoe_encode_buffer(STATUS_CODE_KEY, sz, &p, end) == -1)
482 goto too_big;
483
484 *p++ = SPOE_DATA_T_UINT32;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200485 if (encode_varint(SPOE_APPCTX(appctx)->status_code, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100486 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200487
488 /* "message" K/V item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100489 sz = SLEN(MSG_KEY);
490 if (spoe_encode_buffer(MSG_KEY, sz, &p, end) == -1)
491 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200492
Christopher Faulet8ef75252017-02-20 22:56:03 +0100493 /*Get the message corresponding to the status code */
494 reason = spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code];
495
496 *p++ = SPOE_DATA_T_STR;
497 sz = strlen(reason);
498 if (spoe_encode_buffer(reason, sz, &p, end) == -1)
499 goto too_big;
500
501 return (p - frame);
502
503 too_big:
504 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
505 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200506}
507
Christopher Faulet8ef75252017-02-20 22:56:03 +0100508/* Encode the NOTIFY frame sent by HAProxy to an agent. It returns the number of
509 * encoded bytes in the frame on success, 0 if an encoding error occurred and -1
510 * if a fatal error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200511static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100512spoe_prepare_hanotify_frame(struct appctx *appctx, struct spoe_context *ctx,
Christopher Fauleta1cda022016-12-21 08:58:06 +0100513 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200514{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100515 char *p, *end;
516 unsigned int stream_id, frame_id;
517 unsigned int flags = SPOE_FRM_FL_FIN;
518 size_t sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200519
Christopher Faulet8ef75252017-02-20 22:56:03 +0100520 p = frame;
521 end = frame+size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200522
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100523 stream_id = ctx->stream_id;
524 frame_id = ctx->frame_id;
525
526 if (ctx->flags & SPOE_CTX_FL_FRAGMENTED) {
527 /* The fragmentation is not supported by the applet */
528 if (!(SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_FRAGMENTATION)) {
529 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
530 return -1;
531 }
532 flags = ctx->frag_ctx.flags;
533 }
534
535 /* Set Frame type */
536 *p++ = SPOE_FRM_T_HAPROXY_NOTIFY;
537
538 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200539 flags = htonl(flags);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100540 memcpy(p, (char *)&flags, 4);
541 p += 4;
542
543 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200544 if (encode_varint(stream_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100545 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200546 if (encode_varint(frame_id, &p, end) == -1)
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100547 goto too_big;
548
549 /* Copy encoded messages, if possible */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200550 sz = b_data(&ctx->buffer);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100551 if (p + sz >= end)
552 goto too_big;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200553 memcpy(p, b_head(&ctx->buffer), sz);
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100554 p += sz;
555
556 return (p - frame);
557
558 too_big:
559 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
560 return 0;
561}
562
563/* Encode next part of a fragmented frame sent by HAProxy to an agent. It
564 * returns the number of encoded bytes in the frame on success, 0 if an encoding
565 * error occurred and -1 if a fatal error occurred. */
566static int
567spoe_prepare_hafrag_frame(struct appctx *appctx, struct spoe_context *ctx,
568 char *frame, size_t size)
569{
570 char *p, *end;
571 unsigned int stream_id, frame_id;
572 unsigned int flags;
573 size_t sz;
574
575 p = frame;
576 end = frame+size;
577
Christopher Faulet8ef75252017-02-20 22:56:03 +0100578 /* <ctx> is null when the stream has aborted the processing of a
579 * fragmented frame. In this case, we must notify the corresponding
580 * agent using ids stored in <frag_ctx>. */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100581 if (ctx == NULL) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100582 flags = (SPOE_FRM_FL_FIN|SPOE_FRM_FL_ABRT);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100583 stream_id = SPOE_APPCTX(appctx)->frag_ctx.cursid;
584 frame_id = SPOE_APPCTX(appctx)->frag_ctx.curfid;
585 }
586 else {
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100587 flags = ctx->frag_ctx.flags;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100588 stream_id = ctx->stream_id;
589 frame_id = ctx->frame_id;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100590 }
591
Christopher Faulet8ef75252017-02-20 22:56:03 +0100592 /* Set Frame type */
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100593 *p++ = SPOE_FRM_T_UNSET;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100594
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100595 /* Set flags */
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200596 flags = htonl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100597 memcpy(p, (char *)&flags, 4);
598 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200599
600 /* Set stream-id and frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200601 if (encode_varint(stream_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100602 goto too_big;
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200603 if (encode_varint(frame_id, &p, end) == -1)
Christopher Faulet8ef75252017-02-20 22:56:03 +0100604 goto too_big;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200605
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100606 if (ctx == NULL)
607 goto end;
608
Christopher Faulet8ef75252017-02-20 22:56:03 +0100609 /* Copy encoded messages, if possible */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200610 sz = b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100611 if (p + sz >= end)
612 goto too_big;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200613 memcpy(p, b_head(&ctx->buffer), sz);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100614 p += sz;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100615
Christopher Fauletf032c3e2017-02-17 15:18:35 +0100616 end:
Christopher Faulet8ef75252017-02-20 22:56:03 +0100617 return (p - frame);
618
619 too_big:
620 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
621 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200622}
623
Christopher Faulet8ef75252017-02-20 22:56:03 +0100624/* Decode and process the HELLO frame sent by an agent. It returns the number of
625 * read bytes on success, 0 if a decoding error occurred, and -1 if a fatal
626 * error occurred. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200627static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100628spoe_handle_agenthello_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200629{
Christopher Faulet305c6072017-02-23 16:17:53 +0100630 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
631 char *p, *end;
632 int vsn, max_frame_size;
633 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100634
635 p = frame;
636 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200637
638 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100639 if (*p++ != SPOE_FRM_T_AGENT_HELLO) {
640 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200641 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100642 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200643
Christopher Faulet8ef75252017-02-20 22:56:03 +0100644 if (size < 7 /* TYPE + METADATA */) {
645 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
646 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200647 }
648
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100649 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100650 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200651 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100652 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200653
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100654 /* Fragmentation is not supported for HELLO frame */
655 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100656 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100657 return -1;
658 }
659
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200660 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100661 if (*p != 0 || *(p+1) != 0) {
662 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
663 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200664 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100665 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200666
667 /* There are 3 mandatory items: "version", "max-frame-size" and
668 * "capabilities" */
669
670 /* Loop on K/V items */
Christopher Fauleta1cda022016-12-21 08:58:06 +0100671 vsn = max_frame_size = flags = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100672 while (p < end) {
673 char *str;
Frédéric Lécaille6ca71a92017-08-22 10:33:14 +0200674 uint64_t sz;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100675 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200676
677 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100678 ret = spoe_decode_buffer(&p, end, &str, &sz);
679 if (ret == -1 || !sz) {
680 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
681 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200682 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100683
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200684 /* Check "version" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200685 if (sz >= strlen(VERSION_KEY) && !memcmp(str, VERSION_KEY, strlen(VERSION_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100686 int i, type = *p++;
687
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200688 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100689 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
690 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
691 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200692 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100693 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
694 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
695 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200696 }
697
Christopher Faulet8ef75252017-02-20 22:56:03 +0100698 vsn = spoe_str_to_vsn(str, sz);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200699 if (vsn == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100700 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200701 return -1;
702 }
703 for (i = 0; supported_versions[i].str != NULL; ++i) {
704 if (vsn >= supported_versions[i].min &&
705 vsn <= supported_versions[i].max)
706 break;
707 }
708 if (supported_versions[i].str == NULL) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100709 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200710 return -1;
711 }
712 }
713 /* Check "max-frame-size" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200714 else if (sz >= strlen(MAX_FRAME_SIZE_KEY) && !memcmp(str, MAX_FRAME_SIZE_KEY, strlen(MAX_FRAME_SIZE_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100715 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200716
717 /* The value must be integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200718 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
719 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
720 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
721 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100722 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
723 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200724 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200725 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100726 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
727 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200728 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100729 if (sz < MIN_FRAME_SIZE ||
730 sz > SPOE_APPCTX(appctx)->max_frame_size) {
731 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200732 return -1;
733 }
734 max_frame_size = sz;
735 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100736 /* Check "capabilities" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200737 else if (sz >= strlen(CAPABILITIES_KEY) && !memcmp(str, CAPABILITIES_KEY, strlen(CAPABILITIES_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100738 int type = *p++;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100739
740 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100741 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
742 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
743 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100744 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100745 if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
746 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
747 return 0;
748 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100749
Christopher Faulet8ef75252017-02-20 22:56:03 +0100750 while (sz) {
Christopher Fauleta1cda022016-12-21 08:58:06 +0100751 char *delim;
752
753 /* Skip leading spaces */
Willy Tarreau90807112020-02-25 08:16:33 +0100754 for (; isspace((unsigned char)*str) && sz; str++, sz--);
Christopher Fauleta1cda022016-12-21 08:58:06 +0100755
Christopher Faulet8ef75252017-02-20 22:56:03 +0100756 if (sz >= 10 && !strncmp(str, "pipelining", 10)) {
757 str += 10; sz -= 10;
Willy Tarreau90807112020-02-25 08:16:33 +0100758 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100759 flags |= SPOE_APPCTX_FL_PIPELINING;
760 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100761 else if (sz >= 5 && !strncmp(str, "async", 5)) {
762 str += 5; sz -= 5;
Willy Tarreau90807112020-02-25 08:16:33 +0100763 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauleta1cda022016-12-21 08:58:06 +0100764 flags |= SPOE_APPCTX_FL_ASYNC;
765 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100766 else if (sz >= 13 && !strncmp(str, "fragmentation", 13)) {
767 str += 13; sz -= 13;
Willy Tarreau90807112020-02-25 08:16:33 +0100768 if (!sz || isspace((unsigned char)*str) || *str == ',')
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100769 flags |= SPOE_APPCTX_FL_FRAGMENTATION;
770 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100771
Christopher Faulet8ef75252017-02-20 22:56:03 +0100772 /* Get the next comma or break */
773 if (!sz || (delim = memchr(str, ',', sz)) == NULL)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100774 break;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100775 delim++;
776 sz -= (delim - str);
777 str = delim;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100778 }
779 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200780 else {
781 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100782 if (spoe_skip_data(&p, end) == -1) {
783 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
784 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200785 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200786 }
787 }
788
789 /* Final checks */
790 if (!vsn) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100791 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_VSN;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200792 return -1;
793 }
794 if (!max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100795 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_FRAME_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200796 return -1;
797 }
Christopher Faulet11389012019-02-07 16:13:26 +0100798 if (!agent)
799 flags &= ~(SPOE_APPCTX_FL_PIPELINING|SPOE_APPCTX_FL_ASYNC);
800 else {
801 if ((flags & SPOE_APPCTX_FL_PIPELINING) && !(agent->flags & SPOE_FL_PIPELINING))
802 flags &= ~SPOE_APPCTX_FL_PIPELINING;
803 if ((flags & SPOE_APPCTX_FL_ASYNC) && !(agent->flags & SPOE_FL_ASYNC))
804 flags &= ~SPOE_APPCTX_FL_ASYNC;
805 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200806
Christopher Faulet42bfa462017-01-04 14:14:19 +0100807 SPOE_APPCTX(appctx)->version = (unsigned int)vsn;
808 SPOE_APPCTX(appctx)->max_frame_size = (unsigned int)max_frame_size;
809 SPOE_APPCTX(appctx)->flags |= flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100810
811 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200812}
813
814/* Decode DISCONNECT frame sent by an agent. It returns the number of by read
815 * bytes on success, 0 if the frame can be ignored and -1 if an error
816 * occurred. */
817static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100818spoe_handle_agentdiscon_frame(struct appctx *appctx, char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200819{
Christopher Faulet8ef75252017-02-20 22:56:03 +0100820 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100821 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100822
823 p = frame;
824 end = frame + size;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200825
826 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100827 if (*p++ != SPOE_FRM_T_AGENT_DISCON) {
828 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200829 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100830 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200831
Christopher Faulet8ef75252017-02-20 22:56:03 +0100832 if (size < 7 /* TYPE + METADATA */) {
833 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
834 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200835 }
836
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100837 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100838 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200839 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100840 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200841
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100842 /* Fragmentation is not supported for DISCONNECT frame */
843 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100844 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100845 return -1;
846 }
847
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200848 /* stream-id and frame-id must be cleared */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100849 if (*p != 0 || *(p+1) != 0) {
850 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
851 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200852 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100853 p += 2;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200854
855 /* There are 2 mandatory items: "status-code" and "message" */
856
857 /* Loop on K/V items */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100858 while (p < end) {
859 char *str;
Frédéric Lécaille6ca71a92017-08-22 10:33:14 +0200860 uint64_t sz;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100861 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200862
863 /* Decode the item key */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100864 ret = spoe_decode_buffer(&p, end, &str, &sz);
865 if (ret == -1 || !sz) {
866 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
867 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200868 }
869
870 /* Check "status-code" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200871 if (sz >= strlen(STATUS_CODE_KEY) && !memcmp(str, STATUS_CODE_KEY, strlen(STATUS_CODE_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100872 int type = *p++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200873
874 /* The value must be an integer */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200875 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
876 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
877 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
878 (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100879 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
880 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200881 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200882 if (decode_varint(&p, end, &sz) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100883 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
884 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200885 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100886 SPOE_APPCTX(appctx)->status_code = sz;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200887 }
888
889 /* Check "message" K/V item */
Willy Tarreauda21ed12020-06-16 17:58:14 +0200890 else if (sz >= strlen(MSG_KEY) && !memcmp(str, MSG_KEY, strlen(MSG_KEY))) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100891 int type = *p++;
892
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200893 /* The value must be a string */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100894 if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
895 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
896 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200897 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100898 ret = spoe_decode_buffer(&p, end, &str, &sz);
899 if (ret == -1 || sz > 255) {
900 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
901 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200902 }
Christopher Faulet8ef75252017-02-20 22:56:03 +0100903#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)
904 SPOE_APPCTX(appctx)->reason = str;
905 SPOE_APPCTX(appctx)->rlen = sz;
906#endif
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200907 }
908 else {
909 /* Silently ignore unknown item */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100910 if (spoe_skip_data(&p, end) == -1) {
911 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
912 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200913 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200914 }
915 }
916
Christopher Faulet8ef75252017-02-20 22:56:03 +0100917 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200918}
919
920
Christopher Fauleta1cda022016-12-21 08:58:06 +0100921/* Decode ACK frame sent by an agent. It returns the number of read bytes on
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200922 * success, 0 if the frame can be ignored and -1 if an error occurred. */
923static int
Christopher Faulet8ef75252017-02-20 22:56:03 +0100924spoe_handle_agentack_frame(struct appctx *appctx, struct spoe_context **ctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100925 char *frame, size_t size)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200926{
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100927 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100928 char *p, *end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100929 uint64_t stream_id, frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100930 int len;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100931 unsigned int flags;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100932
933 p = frame;
934 end = frame + size;
935 *ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200936
937 /* Check frame type */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100938 if (*p++ != SPOE_FRM_T_AGENT_ACK) {
939 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200940 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100941 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200942
Christopher Faulet8ef75252017-02-20 22:56:03 +0100943 if (size < 7 /* TYPE + METADATA */) {
944 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
945 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200946 }
947
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100948 /* Retrieve flags */
Christopher Faulet8ef75252017-02-20 22:56:03 +0100949 memcpy((char *)&flags, p, 4);
Thierry FOURNIERc4dcaff2018-05-18 12:25:39 +0200950 flags = ntohl(flags);
Christopher Faulet8ef75252017-02-20 22:56:03 +0100951 p += 4;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200952
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100953 /* Fragmentation is not supported for now */
954 if (!(flags & SPOE_FRM_FL_FIN)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100955 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100956 return -1;
957 }
958
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200959 /* Get the stream-id and the frame-id */
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200960 if (decode_varint(&p, end, &stream_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100961 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauleta1cda022016-12-21 08:58:06 +0100962 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100963 }
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200964 if (decode_varint(&p, end, &frame_id) == -1) {
Christopher Faulet8ef75252017-02-20 22:56:03 +0100965 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200966 return 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +0100967 }
Christopher Fauleta1cda022016-12-21 08:58:06 +0100968
Christopher Faulet8ef75252017-02-20 22:56:03 +0100969 /* Try to find the corresponding SPOE context */
Christopher Faulet42bfa462017-01-04 14:14:19 +0100970 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
Christopher Faulet24289f22017-09-25 14:48:02 +0200971 list_for_each_entry((*ctx), &agent->rt[tid].waiting_queue, list) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100972 if ((*ctx)->stream_id == (unsigned int)stream_id &&
973 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100974 goto found;
975 }
976 }
977 else {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +0100978 list_for_each_entry((*ctx), &SPOE_APPCTX(appctx)->waiting_queue, list) {
979 if ((*ctx)->stream_id == (unsigned int)stream_id &&
Christopher Faulet8ef75252017-02-20 22:56:03 +0100980 (*ctx)->frame_id == (unsigned int)frame_id)
Christopher Fauleta1cda022016-12-21 08:58:06 +0100981 goto found;
982 }
983 }
984
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100985 if (SPOE_APPCTX(appctx)->frag_ctx.ctx &&
986 SPOE_APPCTX(appctx)->frag_ctx.cursid == (unsigned int)stream_id &&
987 SPOE_APPCTX(appctx)->frag_ctx.curfid == (unsigned int)frame_id) {
988
989 /* ABRT bit is set for an unfinished fragmented frame */
990 if (flags & SPOE_FRM_FL_ABRT) {
991 *ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
Christopher Faulet8eda93f2017-02-09 09:44:33 +0100992 (*ctx)->state = SPOE_CTX_ST_ERROR;
993 (*ctx)->status_code = SPOE_CTX_ERR_FRAG_FRAME_ABRT;
994 /* Ignore the payload */
995 goto end;
996 }
997 /* TODO: Handle more flags for fragmented frames: RESUME, FINISH... */
998 /* For now, we ignore the ack */
999 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
1000 return 0;
1001 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001002
Christopher Fauleta1cda022016-12-21 08:58:06 +01001003 /* No Stream found, ignore the frame */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001004 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1005 " - Ignore ACK frame"
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001006 " - stream-id=%u - frame-id=%u\n",
1007 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1008 __FUNCTION__, appctx,
1009 (unsigned int)stream_id, (unsigned int)frame_id);
1010
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001011 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAMEID_NOTFOUND;
Christopher Fauletd9eb3c32020-11-10 14:31:39 +01001012 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK) {
1013 /* Report an error if we are waiting the ack for another frame,
1014 * but not if there is no longer frame waiting for a ack
1015 * (timeout)
1016 */
1017 if (!LIST_ISEMPTY(&SPOE_APPCTX(appctx)->waiting_queue) ||
1018 SPOE_APPCTX(appctx)->frag_ctx.ctx)
1019 return -1;
1020 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1021 SPOE_APPCTX(appctx)->cur_fpa = 0;
1022 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001023 return 0;
1024
1025 found:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001026 if (!spoe_acquire_buffer(&SPOE_APPCTX(appctx)->buffer,
1027 &SPOE_APPCTX(appctx)->buffer_wait)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001028 *ctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001029 return 1; /* Retry later */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001030 }
Christopher Faulet4596fb72017-01-11 14:05:19 +01001031
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001032 /* Copy encoded actions */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001033 len = (end - p);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001034 memcpy(b_head(&SPOE_APPCTX(appctx)->buffer), p, len);
1035 b_set_data(&SPOE_APPCTX(appctx)->buffer, len);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001036 p += len;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001037
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001038 /* Transfer the buffer ownership to the SPOE context */
1039 (*ctx)->buffer = SPOE_APPCTX(appctx)->buffer;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001040 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001041
Christopher Faulet8ef75252017-02-20 22:56:03 +01001042 (*ctx)->state = SPOE_CTX_ST_DONE;
1043
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001044 end:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001045 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001046 " - ACK frame received"
1047 " - ctx=%p - stream-id=%u - frame-id=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001048 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001049 __FUNCTION__, appctx, *ctx, (*ctx)->stream_id,
1050 (*ctx)->frame_id, flags);
1051 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001052}
1053
Christopher Fauletba7bc162016-11-07 21:07:38 +01001054/* This function is used in cfgparse.c and declared in proto/checks.h. It
1055 * prepare the request to send to agents during a healthcheck. It returns 0 on
1056 * success and -1 if an error occurred. */
1057int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001058spoe_prepare_healthcheck_request(char **req, int *len)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001059{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001060 struct appctx appctx;
1061 struct spoe_appctx spoe_appctx;
1062 char *frame, *end, buf[MAX_FRAME_SIZE+4];
1063 size_t sz;
1064 int ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001065
Christopher Faulet42bfa462017-01-04 14:14:19 +01001066 memset(&appctx, 0, sizeof(appctx));
1067 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001068 memset(buf, 0, sizeof(buf));
Christopher Faulet42bfa462017-01-04 14:14:19 +01001069
1070 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001071 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001072
Christopher Faulet8ef75252017-02-20 22:56:03 +01001073 frame = buf+4; /* Reserved the 4 first bytes for the frame size */
1074 end = frame + MAX_FRAME_SIZE;
1075
1076 ret = spoe_prepare_hahello_frame(&appctx, frame, MAX_FRAME_SIZE);
1077 if (ret <= 0)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001078 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001079 frame += ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001080
Christopher Faulet8ef75252017-02-20 22:56:03 +01001081 /* Add "healthcheck" K/V item */
1082 sz = SLEN(HEALTHCHECK_KEY);
1083 if (spoe_encode_buffer(HEALTHCHECK_KEY, sz, &frame, end) == -1)
1084 return -1;
1085 *frame++ = (SPOE_DATA_T_BOOL | SPOE_DATA_FL_TRUE);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001086
Christopher Faulet8ef75252017-02-20 22:56:03 +01001087 *len = frame - buf;
1088 sz = htonl(*len - 4);
1089 memcpy(buf, (char *)&sz, 4);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001090
Christopher Faulet8ef75252017-02-20 22:56:03 +01001091 if ((*req = malloc(*len)) == NULL)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001092 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001093 memcpy(*req, buf, *len);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001094 return 0;
1095}
1096
1097/* This function is used in checks.c and declared in proto/checks.h. It decode
1098 * the response received from an agent during a healthcheck. It returns 0 on
1099 * success and -1 if an error occurred. */
1100int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001101spoe_handle_healthcheck_response(char *frame, size_t size, char *err, int errlen)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001102{
Christopher Faulet42bfa462017-01-04 14:14:19 +01001103 struct appctx appctx;
1104 struct spoe_appctx spoe_appctx;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001105
Christopher Faulet42bfa462017-01-04 14:14:19 +01001106 memset(&appctx, 0, sizeof(appctx));
1107 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001108
Christopher Faulet42bfa462017-01-04 14:14:19 +01001109 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001110 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001111
Christopher Faulet8ef75252017-02-20 22:56:03 +01001112 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1113 spoe_handle_agentdiscon_frame(&appctx, frame, size);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001114 goto error;
1115 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001116 if (spoe_handle_agenthello_frame(&appctx, frame, size) <= 0)
1117 goto error;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001118
1119 return 0;
1120
1121 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001122 if (SPOE_APPCTX(&appctx)->status_code >= SPOE_FRM_ERRS)
1123 SPOE_APPCTX(&appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
1124 strncpy(err, spoe_frm_err_reasons[SPOE_APPCTX(&appctx)->status_code], errlen);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001125 return -1;
1126}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001127
Christopher Fauleta1cda022016-12-21 08:58:06 +01001128/* Send a SPOE frame to an agent. It returns -1 when an error occurred, 0 when
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05001129 * the frame can be ignored, 1 to retry later, and the frame length on
Christopher Fauleta1cda022016-12-21 08:58:06 +01001130 * success. */
1131static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001132spoe_send_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001133{
1134 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001135 int ret;
1136 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001137
Christopher Faulet8ef75252017-02-20 22:56:03 +01001138 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1139 * length. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001140 netint = htonl(framesz);
1141 memcpy(buf, (char *)&netint, 4);
Willy Tarreau06d80a92017-10-19 14:32:15 +02001142 ret = ci_putblk(si_ic(si), buf, framesz+4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001143 if (ret <= 0) {
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001144 if ((ret == -3 && b_is_null(&si_ic(si)->buf)) || ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001145 si_rx_room_blk(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001146 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001147 }
1148 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001149 return -1; /* error */
1150 }
1151 return framesz;
1152}
1153
1154/* Receive a SPOE frame from an agent. It return -1 when an error occurred, 0
1155 * when the frame can be ignored, 1 to retry later and the frame length on
1156 * success. */
1157static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001158spoe_recv_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001159{
1160 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001161 int ret;
1162 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001163
Willy Tarreau06d80a92017-10-19 14:32:15 +02001164 ret = co_getblk(si_oc(si), (char *)&netint, 4, 0);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001165 if (ret > 0) {
1166 framesz = ntohl(netint);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001167 if (framesz > SPOE_APPCTX(appctx)->max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001168 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001169 return -1;
1170 }
Willy Tarreau06d80a92017-10-19 14:32:15 +02001171 ret = co_getblk(si_oc(si), buf, framesz, 4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001172 }
1173 if (ret <= 0) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001174 if (ret == 0) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001175 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001176 }
1177 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001178 return -1; /* error */
1179 }
1180 return framesz;
1181}
1182
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001183/********************************************************************
1184 * Functions that manage the SPOE applet
1185 ********************************************************************/
Christopher Faulet4596fb72017-01-11 14:05:19 +01001186static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001187spoe_wakeup_appctx(struct appctx *appctx)
Christopher Faulet4596fb72017-01-11 14:05:19 +01001188{
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001189 si_want_get(appctx->owner);
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001190 si_rx_endp_more(appctx->owner);
Christopher Faulet4596fb72017-01-11 14:05:19 +01001191 appctx_wakeup(appctx);
1192 return 1;
1193}
1194
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001195/* Callback function that catches applet timeouts. If a timeout occurred, we set
1196 * <appctx->st1> flag and the SPOE applet is woken up. */
1197static struct task *
Olivier Houchard9f6af332018-05-25 14:04:04 +02001198spoe_process_appctx(struct task * task, void *context, unsigned short state)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001199{
Olivier Houchard9f6af332018-05-25 14:04:04 +02001200 struct appctx *appctx = context;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001201
1202 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1203 if (tick_is_expired(task->expire, now_ms)) {
1204 task->expire = TICK_ETERNITY;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001205 appctx->st1 = SPOE_APPCTX_ERR_TOUT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001206 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001207 spoe_wakeup_appctx(appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001208 return task;
1209}
1210
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001211/* Callback function that releases a SPOE applet. This happens when the
1212 * connection with the agent is closed. */
1213static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001214spoe_release_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001215{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001216 struct stream_interface *si = appctx->owner;
1217 struct spoe_appctx *spoe_appctx = SPOE_APPCTX(appctx);
1218 struct spoe_agent *agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001219 struct spoe_context *ctx, *back;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001220
1221 if (spoe_appctx == NULL)
1222 return;
1223
1224 appctx->ctx.spoe.ptr = NULL;
1225 agent = spoe_appctx->agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001226
1227 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p\n",
1228 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1229 __FUNCTION__, appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001230
Christopher Faulet8ef75252017-02-20 22:56:03 +01001231 /* Remove applet from the list of running applets */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001232 _HA_ATOMIC_SUB(&agent->counters.applets, 1);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001233 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001234 if (!LIST_ISEMPTY(&spoe_appctx->list)) {
1235 LIST_DEL(&spoe_appctx->list);
1236 LIST_INIT(&spoe_appctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001237 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001238 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001239
Christopher Faulet8ef75252017-02-20 22:56:03 +01001240 /* Shutdown the server connection, if needed */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001241 if (appctx->st0 != SPOE_APPCTX_ST_END) {
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001242 if (appctx->st0 == SPOE_APPCTX_ST_IDLE) {
1243 eb32_delete(&spoe_appctx->node);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001244 _HA_ATOMIC_SUB(&agent->counters.idles, 1);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001245 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001246
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001247 appctx->st0 = SPOE_APPCTX_ST_END;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001248 if (spoe_appctx->status_code == SPOE_FRM_ERR_NONE)
1249 spoe_appctx->status_code = SPOE_FRM_ERR_IO;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001250
1251 si_shutw(si);
1252 si_shutr(si);
1253 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001254 }
1255
Christopher Faulet8ef75252017-02-20 22:56:03 +01001256 /* Destroy the task attached to this applet */
Willy Tarreauf6562792019-05-07 19:05:35 +02001257 task_destroy(spoe_appctx->task);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001258
Christopher Faulet8ef75252017-02-20 22:56:03 +01001259 /* Notify all waiting streams */
1260 list_for_each_entry_safe(ctx, back, &spoe_appctx->waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001261 LIST_DEL(&ctx->list);
1262 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001263 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001264 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauletabe894d2020-11-10 18:45:34 +01001265 ctx->spoe_appctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001266 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001267 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001268 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001269 }
1270
Christopher Faulet8ef75252017-02-20 22:56:03 +01001271 /* If the applet was processing a fragmented frame, notify the
1272 * corresponding stream. */
1273 if (spoe_appctx->frag_ctx.ctx) {
1274 ctx = spoe_appctx->frag_ctx.ctx;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001275 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001276 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001277 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001278 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1279 }
1280
Christopher Fauletabe894d2020-11-10 18:45:34 +01001281 if (!LIST_ISEMPTY(&agent->rt[tid].applets)) {
1282 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
1283 if (ctx->spoe_appctx == spoe_appctx)
1284 ctx->spoe_appctx = NULL;
1285 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001286 goto end;
Christopher Fauletabe894d2020-11-10 18:45:34 +01001287 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001288
Christopher Faulet8ef75252017-02-20 22:56:03 +01001289 /* If this was the last running applet, notify all waiting streams */
Christopher Faulet24289f22017-09-25 14:48:02 +02001290 list_for_each_entry_safe(ctx, back, &agent->rt[tid].sending_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001291 LIST_DEL(&ctx->list);
1292 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001293 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001294 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletabe894d2020-11-10 18:45:34 +01001295 ctx->spoe_appctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001296 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001297 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001298 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001299 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001300 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001301 LIST_DEL(&ctx->list);
1302 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001303 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001304 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauletabe894d2020-11-10 18:45:34 +01001305 ctx->spoe_appctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001306 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001307 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001308 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1309 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001310
1311 end:
Christopher Faulet55ae8a62019-05-23 22:47:48 +02001312 /* Release allocated memory */
1313 spoe_release_buffer(&spoe_appctx->buffer,
1314 &spoe_appctx->buffer_wait);
1315 pool_free(pool_head_spoe_appctx, spoe_appctx);
1316
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001317 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001318 agent->rt[tid].frame_size = agent->max_frame_size;
1319 list_for_each_entry(spoe_appctx, &agent->rt[tid].applets, list)
1320 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, spoe_appctx->max_frame_size);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001321}
1322
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001323static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001324spoe_handle_connect_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001325{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001326 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001327 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001328 char *frame, *buf;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001329 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001330
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001331 if (si_state_in(si->state, SI_SB_CER|SI_SB_DIS|SI_SB_CLO)) {
1332 /* closed */
1333 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1334 goto exit;
1335 }
1336
Willy Tarreau4f283fa2019-06-05 14:34:03 +02001337 if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST)) {
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001338 /* not connected yet */
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001339 si_rx_endp_more(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001340 task_wakeup(si_strm(si)->task, TASK_WOKEN_MSG);
1341 goto stop;
1342 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001343
Christopher Fauleta1cda022016-12-21 08:58:06 +01001344 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001345 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1346 " - Connection timed out\n",
1347 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1348 __FUNCTION__, appctx);
1349 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001350 goto exit;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001351 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001352
Christopher Faulet42bfa462017-01-04 14:14:19 +01001353 if (SPOE_APPCTX(appctx)->task->expire == TICK_ETERNITY)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001354 SPOE_APPCTX(appctx)->task->expire =
1355 tick_add_ifset(now_ms, agent->timeout.hello);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001356
Christopher Faulet8ef75252017-02-20 22:56:03 +01001357 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1358 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001359 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001360 ret = spoe_prepare_hahello_frame(appctx, frame,
1361 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001362 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001363 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001364
1365 switch (ret) {
1366 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001367 case 0: /* ignore => an error, cannot be ignored */
1368 goto exit;
1369
1370 case 1: /* retry later */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001371 goto stop;
1372
Christopher Faulet8ef75252017-02-20 22:56:03 +01001373 default:
1374 /* HELLO frame successfully sent, now wait for the
1375 * reply. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001376 appctx->st0 = SPOE_APPCTX_ST_CONNECTING;
1377 goto next;
1378 }
1379
1380 next:
1381 return 0;
1382 stop:
1383 return 1;
1384 exit:
1385 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1386 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001387}
1388
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001389static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001390spoe_handle_connecting_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001391{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001392 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001393 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001394 char *frame;
1395 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001396
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001397
Christopher Fauletb067b062017-01-04 16:39:11 +01001398 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001399 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001400 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001401 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001402
Christopher Fauleta1cda022016-12-21 08:58:06 +01001403 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001404 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1405 " - Connection timed out\n",
1406 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1407 __FUNCTION__, appctx);
1408 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001409 goto exit;
1410 }
1411
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001412 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001413 ret = spoe_recv_frame(appctx, frame,
1414 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001415 if (ret > 1) {
1416 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1417 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1418 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001419 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001420 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001421 ret = spoe_handle_agenthello_frame(appctx, frame, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001422 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001423
Christopher Fauleta1cda022016-12-21 08:58:06 +01001424 switch (ret) {
1425 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001426 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001427 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1428 goto next;
1429
1430 case 1: /* retry later */
1431 goto stop;
1432
1433 default:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001434 /* HELLO handshake is finished, set the idle timeout and
1435 * add the applet in the list of running applets. */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001436 _HA_ATOMIC_ADD(&agent->counters.idles, 1);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001437 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001438 SPOE_APPCTX(appctx)->node.key = 0;
1439 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001440
1441 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001442 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001443 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001444 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001445
Christopher Fauleta1cda022016-12-21 08:58:06 +01001446 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001447 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001448 if (trash.data)
1449 co_skip(si_oc(si), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001450
1451 SPOE_APPCTX(appctx)->task->expire =
1452 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001453 return 0;
1454 stop:
1455 return 1;
1456 exit:
1457 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1458 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001459}
1460
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001461
Christopher Fauleta1cda022016-12-21 08:58:06 +01001462static int
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001463spoe_handle_sending_frame_appctx(struct appctx *appctx, int *skip)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001464{
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001465 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
1466 struct spoe_context *ctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001467 char *frame, *buf;
1468 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001469
Christopher Faulet8ef75252017-02-20 22:56:03 +01001470 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1471 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001472 buf = trash.area; frame = buf+4;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001473
1474 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY) {
1475 ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
1476 ret = spoe_prepare_hafrag_frame(appctx, ctx, frame,
1477 SPOE_APPCTX(appctx)->max_frame_size);
1478 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001479 else if (LIST_ISEMPTY(&agent->rt[tid].sending_queue)) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001480 *skip = 1;
1481 ret = 1;
1482 goto end;
1483 }
1484 else {
Christopher Faulet24289f22017-09-25 14:48:02 +02001485 ctx = LIST_NEXT(&agent->rt[tid].sending_queue, typeof(ctx), list);
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001486 ret = spoe_prepare_hanotify_frame(appctx, ctx, frame,
1487 SPOE_APPCTX(appctx)->max_frame_size);
1488
1489 }
1490
Christopher Faulet8ef75252017-02-20 22:56:03 +01001491 if (ret > 1)
1492 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001493
Christopher Faulet8ef75252017-02-20 22:56:03 +01001494 switch (ret) {
1495 case -1: /* error */
1496 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1497 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001498
Christopher Faulet8ef75252017-02-20 22:56:03 +01001499 case 0: /* ignore */
1500 if (ctx == NULL)
1501 goto abort_frag_frame;
1502
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001503 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001504 LIST_DEL(&ctx->list);
1505 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001506 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001507 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001508 ctx->spoe_appctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001509 ctx->state = SPOE_CTX_ST_ERROR;
1510 ctx->status_code = (SPOE_APPCTX(appctx)->status_code + 0x100);
1511 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001512 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001513 break;
1514
1515 case 1: /* retry */
1516 *skip = 1;
1517 break;
1518
1519 default:
1520 if (ctx == NULL)
1521 goto abort_frag_frame;
1522
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001523 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001524 LIST_DEL(&ctx->list);
1525 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001526 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001527 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001528 ctx->spoe_appctx = SPOE_APPCTX(appctx);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001529 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) ||
1530 (ctx->frag_ctx.flags & SPOE_FRM_FL_FIN))
1531 goto no_frag_frame_sent;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001532 else
Christopher Faulet8ef75252017-02-20 22:56:03 +01001533 goto frag_frame_sent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001534 }
1535 goto end;
1536
1537 frag_frame_sent:
1538 appctx->st0 = SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001539 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001540 SPOE_APPCTX(appctx)->frag_ctx.ctx = ctx;
1541 SPOE_APPCTX(appctx)->frag_ctx.cursid = ctx->stream_id;
1542 SPOE_APPCTX(appctx)->frag_ctx.curfid = ctx->frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001543 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
1544 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1545 goto end;
1546
1547 no_frag_frame_sent:
1548 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
1549 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet24289f22017-09-25 14:48:02 +02001550 LIST_ADDQ(&agent->rt[tid].waiting_queue, &ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001551 }
1552 else if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_PIPELINING) {
1553 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1554 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1555 }
1556 else {
1557 appctx->st0 = SPOE_APPCTX_ST_WAITING_SYNC_ACK;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001558 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001559 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1560 }
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001561 _HA_ATOMIC_ADD(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001562 ctx->stats.tv_wait = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001563 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1564 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1565 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001566 SPOE_APPCTX(appctx)->cur_fpa++;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001567
Christopher Faulet8ef75252017-02-20 22:56:03 +01001568 ctx->state = SPOE_CTX_ST_WAITING_ACK;
1569 goto end;
1570
1571 abort_frag_frame:
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 goto end;
1577
1578 end:
1579 return ret;
1580}
1581
1582static int
1583spoe_handle_receiving_frame_appctx(struct appctx *appctx, int *skip)
1584{
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02001585 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001586 struct spoe_context *ctx = NULL;
1587 char *frame;
1588 int ret;
1589
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001590 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001591 ret = spoe_recv_frame(appctx, frame,
1592 SPOE_APPCTX(appctx)->max_frame_size);
1593 if (ret > 1) {
1594 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1595 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001596 ret = -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001597 goto end;
1598 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001599 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001600 ret = spoe_handle_agentack_frame(appctx, &ctx, frame, ret);
1601 }
1602 switch (ret) {
1603 case -1: /* error */
1604 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1605 break;
1606
1607 case 0: /* ignore */
1608 break;
1609
1610 case 1: /* retry */
1611 *skip = 1;
1612 break;
1613
1614 default:
1615 LIST_DEL(&ctx->list);
1616 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001617 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001618 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
1619 ctx->stats.tv_response = now;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001620 if (ctx->spoe_appctx) {
1621 ctx->spoe_appctx->cur_fpa--;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001622 ctx->spoe_appctx = NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001623 }
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001624 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY &&
1625 ctx == SPOE_APPCTX(appctx)->frag_ctx.ctx) {
1626 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1627 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1628 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1629 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1630 }
1631 else if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1632 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001633 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1634 break;
1635 }
1636
1637 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001638 if (trash.data)
1639 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001640 end:
1641 return ret;
1642}
1643
1644static int
1645spoe_handle_processing_appctx(struct appctx *appctx)
1646{
1647 struct stream_interface *si = appctx->owner;
1648 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001649 int ret, skip_sending = 0, skip_receiving = 0, active_s = 0, active_r = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001650
1651 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
1652 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1653 goto exit;
1654 }
1655
1656 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
1657 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
1658 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1659 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1660 goto next;
1661 }
1662
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001663 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001664 " - process: fpa=%u/%u - appctx-state=%s - weight=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001665 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8f82b202018-01-24 16:23:03 +01001666 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->cur_fpa,
1667 agent->max_fpa, spoe_appctx_state_str[appctx->st0],
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001668 SPOE_APPCTX(appctx)->node.key, SPOE_APPCTX(appctx)->flags);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001669
Christopher Faulet8f82b202018-01-24 16:23:03 +01001670 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1671 skip_sending = 1;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001672
Christopher Faulet8f82b202018-01-24 16:23:03 +01001673 /* receiving_frame loop */
1674 while (!skip_receiving) {
1675 ret = spoe_handle_receiving_frame_appctx(appctx, &skip_receiving);
1676 switch (ret) {
1677 case -1: /* error */
1678 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001679
Christopher Faulet8f82b202018-01-24 16:23:03 +01001680 case 0: /* ignore */
1681 active_r = 1;
1682 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001683
Christopher Faulet8f82b202018-01-24 16:23:03 +01001684 case 1: /* retry */
1685 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001686
Christopher Faulet8f82b202018-01-24 16:23:03 +01001687 default:
1688 active_r = 1;
1689 break;
1690 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001691 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001692
Christopher Faulet8f82b202018-01-24 16:23:03 +01001693 /* send_frame loop */
1694 while (!skip_sending && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
1695 ret = spoe_handle_sending_frame_appctx(appctx, &skip_sending);
1696 switch (ret) {
1697 case -1: /* error */
1698 goto next;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001699
Christopher Faulet8f82b202018-01-24 16:23:03 +01001700 case 0: /* ignore */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001701 if (SPOE_APPCTX(appctx)->node.key)
1702 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001703 active_s++;
1704 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001705
Christopher Faulet8f82b202018-01-24 16:23:03 +01001706 case 1: /* retry */
1707 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001708
Christopher Faulet8f82b202018-01-24 16:23:03 +01001709 default:
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001710 if (SPOE_APPCTX(appctx)->node.key)
1711 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001712 active_s++;
1713 break;
1714 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001715 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001716
Christopher Faulet8f82b202018-01-24 16:23:03 +01001717 if (active_s || active_r) {
Christopher Faulet8f82b202018-01-24 16:23:03 +01001718 update_freq_ctr(&agent->rt[tid].processing_per_sec, active_s);
1719 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1720 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001721
Christopher Faulet8f82b202018-01-24 16:23:03 +01001722 if (appctx->st0 == SPOE_APPCTX_ST_PROCESSING && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001723 _HA_ATOMIC_ADD(&agent->counters.idles, 1);
Christopher Faulet8f82b202018-01-24 16:23:03 +01001724 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001725 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001726 }
1727 return 1;
1728
Christopher Faulet8f82b202018-01-24 16:23:03 +01001729 next:
1730 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1731 return 0;
1732
Christopher Fauleta1cda022016-12-21 08:58:06 +01001733 exit:
1734 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1735 return 0;
1736}
1737
1738static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001739spoe_handle_disconnect_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001740{
1741 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001742 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001743 char *frame, *buf;
1744 int ret;
Christopher Fauletb067b062017-01-04 16:39:11 +01001745
Christopher Fauleta1cda022016-12-21 08:58:06 +01001746 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO)
1747 goto exit;
1748
1749 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT)
1750 goto exit;
1751
Christopher Faulet8ef75252017-02-20 22:56:03 +01001752 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1753 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001754 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001755 ret = spoe_prepare_hadiscon_frame(appctx, frame,
1756 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001757 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001758 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001759
1760 switch (ret) {
1761 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001762 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001763 goto exit;
1764
1765 case 1: /* retry */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001766 goto stop;
1767
1768 default:
1769 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1770 " - disconnected by HAProxy (%d): %s\n",
1771 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001772 __FUNCTION__, appctx,
1773 SPOE_APPCTX(appctx)->status_code,
1774 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001775
1776 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1777 goto next;
1778 }
1779
1780 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001781 SPOE_APPCTX(appctx)->task->expire =
1782 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001783 return 0;
1784 stop:
1785 return 1;
1786 exit:
1787 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1788 return 0;
1789}
1790
1791static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001792spoe_handle_disconnecting_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001793{
1794 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001795 char *frame;
1796 int ret;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001797
Christopher Fauletb067b062017-01-04 16:39:11 +01001798 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001799 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001800 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001801 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001802
Christopher Fauletb067b062017-01-04 16:39:11 +01001803 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001804 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001805 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001806 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001807
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001808 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001809 ret = spoe_recv_frame(appctx, frame,
1810 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001811 if (ret > 1) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001812 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001813 ret = spoe_handle_agentdiscon_frame(appctx, frame, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001814 }
1815
1816 switch (ret) {
1817 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001818 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1819 " - error on frame (%s)\n",
1820 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001821 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Fauleta1cda022016-12-21 08:58:06 +01001822 __FUNCTION__, appctx,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001823 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001824 goto exit;
1825
1826 case 0: /* ignore */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001827 goto next;
1828
1829 case 1: /* retry */
1830 goto stop;
1831
1832 default:
Christopher Fauleta1cda022016-12-21 08:58:06 +01001833 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001834 " - disconnected by peer (%d): %.*s\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01001835 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001836 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001837 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->status_code,
1838 SPOE_APPCTX(appctx)->rlen, SPOE_APPCTX(appctx)->reason);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001839 goto exit;
1840 }
1841
1842 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001843 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001844 if (trash.data)
1845 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001846
Christopher Fauleta1cda022016-12-21 08:58:06 +01001847 return 0;
1848 stop:
1849 return 1;
1850 exit:
1851 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1852 return 0;
1853}
1854
1855/* I/O Handler processing messages exchanged with the agent */
1856static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001857spoe_handle_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001858{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001859 struct stream_interface *si = appctx->owner;
1860 struct spoe_agent *agent;
1861
1862 if (SPOE_APPCTX(appctx) == NULL)
1863 return;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001864
Christopher Faulet8ef75252017-02-20 22:56:03 +01001865 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
1866 agent = SPOE_APPCTX(appctx)->agent;
Christopher Fauletb067b062017-01-04 16:39:11 +01001867
Christopher Fauleta1cda022016-12-21 08:58:06 +01001868 switchstate:
1869 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1870 " - appctx-state=%s\n",
1871 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1872 __FUNCTION__, appctx, spoe_appctx_state_str[appctx->st0]);
1873
1874 switch (appctx->st0) {
1875 case SPOE_APPCTX_ST_CONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001876 if (spoe_handle_connect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001877 goto out;
1878 goto switchstate;
1879
1880 case SPOE_APPCTX_ST_CONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001881 if (spoe_handle_connecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001882 goto out;
1883 goto switchstate;
1884
1885 case SPOE_APPCTX_ST_IDLE:
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001886 _HA_ATOMIC_SUB(&agent->counters.idles, 1);
Christopher Faulet7d9f1ba2018-02-28 13:33:26 +01001887 eb32_delete(&SPOE_APPCTX(appctx)->node);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001888 if (stopping &&
Christopher Faulet24289f22017-09-25 14:48:02 +02001889 LIST_ISEMPTY(&agent->rt[tid].sending_queue) &&
Christopher Faulet42bfa462017-01-04 14:14:19 +01001890 LIST_ISEMPTY(&SPOE_APPCTX(appctx)->waiting_queue)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001891 SPOE_APPCTX(appctx)->task->expire =
1892 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001893 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001894 goto switchstate;
1895 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001896 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1897 /* fall through */
1898
1899 case SPOE_APPCTX_ST_PROCESSING:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001900 case SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY:
1901 case SPOE_APPCTX_ST_WAITING_SYNC_ACK:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001902 if (spoe_handle_processing_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001903 goto out;
1904 goto switchstate;
1905
1906 case SPOE_APPCTX_ST_DISCONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001907 if (spoe_handle_disconnect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001908 goto out;
1909 goto switchstate;
1910
1911 case SPOE_APPCTX_ST_DISCONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001912 if (spoe_handle_disconnecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001913 goto out;
1914 goto switchstate;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001915
1916 case SPOE_APPCTX_ST_EXIT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001917 appctx->st0 = SPOE_APPCTX_ST_END;
1918 SPOE_APPCTX(appctx)->task->expire = TICK_ETERNITY;
1919
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001920 si_shutw(si);
1921 si_shutr(si);
1922 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001923 /* fall through */
1924
1925 case SPOE_APPCTX_ST_END:
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001926 return;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001927 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001928 out:
Christopher Faulet24289f22017-09-25 14:48:02 +02001929 if (stopping)
1930 spoe_wakeup_appctx(appctx);
1931
Christopher Faulet42bfa462017-01-04 14:14:19 +01001932 if (SPOE_APPCTX(appctx)->task->expire != TICK_ETERNITY)
1933 task_queue(SPOE_APPCTX(appctx)->task);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001934}
1935
1936struct applet spoe_applet = {
1937 .obj_type = OBJ_TYPE_APPLET,
1938 .name = "<SPOE>", /* used for logging */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001939 .fct = spoe_handle_appctx,
1940 .release = spoe_release_appctx,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001941};
1942
1943/* Create a SPOE applet. On success, the created applet is returned, else
1944 * NULL. */
1945static struct appctx *
Christopher Faulet8ef75252017-02-20 22:56:03 +01001946spoe_create_appctx(struct spoe_config *conf)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001947{
1948 struct appctx *appctx;
1949 struct session *sess;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001950 struct stream *strm;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001951
Emeric Brun1138fd02017-06-19 12:38:55 +02001952 if ((appctx = appctx_new(&spoe_applet, tid_bit)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001953 goto out_error;
1954
Willy Tarreaubafbe012017-11-24 17:34:44 +01001955 appctx->ctx.spoe.ptr = pool_alloc_dirty(pool_head_spoe_appctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001956 if (SPOE_APPCTX(appctx) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001957 goto out_free_appctx;
Willy Tarreaubafbe012017-11-24 17:34:44 +01001958 memset(appctx->ctx.spoe.ptr, 0, pool_head_spoe_appctx->size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001959
Christopher Faulet42bfa462017-01-04 14:14:19 +01001960 appctx->st0 = SPOE_APPCTX_ST_CONNECT;
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01001961 if ((SPOE_APPCTX(appctx)->task = task_new(tid_bit)) == NULL)
Christopher Faulet42bfa462017-01-04 14:14:19 +01001962 goto out_free_spoe_appctx;
1963
1964 SPOE_APPCTX(appctx)->owner = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001965 SPOE_APPCTX(appctx)->task->process = spoe_process_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001966 SPOE_APPCTX(appctx)->task->context = appctx;
1967 SPOE_APPCTX(appctx)->agent = conf->agent;
1968 SPOE_APPCTX(appctx)->version = 0;
1969 SPOE_APPCTX(appctx)->max_frame_size = conf->agent->max_frame_size;
1970 SPOE_APPCTX(appctx)->flags = 0;
Christopher Fauletb067b062017-01-04 16:39:11 +01001971 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001972 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001973 SPOE_APPCTX(appctx)->cur_fpa = 0;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001974
Willy Tarreau21046592020-02-26 10:39:36 +01001975 MT_LIST_INIT(&SPOE_APPCTX(appctx)->buffer_wait.list);
Christopher Faulet4596fb72017-01-11 14:05:19 +01001976 SPOE_APPCTX(appctx)->buffer_wait.target = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001977 SPOE_APPCTX(appctx)->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001978
1979 LIST_INIT(&SPOE_APPCTX(appctx)->list);
1980 LIST_INIT(&SPOE_APPCTX(appctx)->waiting_queue);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001981
Willy Tarreau5820a362016-12-22 15:59:02 +01001982 sess = session_new(&conf->agent_fe, NULL, &appctx->obj_type);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001983 if (!sess)
1984 goto out_free_spoe;
1985
Willy Tarreau87787ac2017-08-28 16:22:54 +02001986 if ((strm = stream_new(sess, &appctx->obj_type)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001987 goto out_free_sess;
1988
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001989 stream_set_backend(strm, conf->agent->b.be);
1990
1991 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001992 si_cant_get(&strm->si[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001993 appctx_wakeup(appctx);
1994
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001995 strm->do_log = NULL;
1996 strm->res.flags |= CF_READ_DONTWAIT;
1997
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001998 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02001999 LIST_ADDQ(&conf->agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002000 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002001 _HA_ATOMIC_ADD(&conf->agent->counters.applets, 1);
Emeric Brun5f77fef2017-05-29 15:26:51 +02002002
Emeric Brunc60def82017-09-27 14:59:38 +02002003 task_wakeup(SPOE_APPCTX(appctx)->task, TASK_WOKEN_INIT);
Willy Tarreau87787ac2017-08-28 16:22:54 +02002004 task_wakeup(strm->task, TASK_WOKEN_INIT);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002005 return appctx;
2006
2007 /* Error unrolling */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002008 out_free_sess:
2009 session_free(sess);
2010 out_free_spoe:
Olivier Houchard3f795f72019-04-17 22:51:06 +02002011 task_destroy(SPOE_APPCTX(appctx)->task);
Christopher Faulet42bfa462017-01-04 14:14:19 +01002012 out_free_spoe_appctx:
Willy Tarreaubafbe012017-11-24 17:34:44 +01002013 pool_free(pool_head_spoe_appctx, SPOE_APPCTX(appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002014 out_free_appctx:
2015 appctx_free(appctx);
2016 out_error:
2017 return NULL;
2018}
2019
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002020static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002021spoe_queue_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002022{
2023 struct spoe_config *conf = FLT_CONF(ctx->filter);
2024 struct spoe_agent *agent = conf->agent;
2025 struct appctx *appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002026 struct spoe_appctx *spoe_appctx;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002027
Christopher Fauleta1cda022016-12-21 08:58:06 +01002028 /* Check if we need to create a new SPOE applet or not. */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002029 if (!eb_is_empty(&agent->rt[tid].idle_applets) &&
Christopher Fauleteccfa612020-06-22 15:32:14 +02002030 (agent->rt[tid].processing == 1 || agent->rt[tid].processing < read_freq_ctr(&agent->rt[tid].processing_per_sec)))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002031 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002032
2033 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauleta1cda022016-12-21 08:58:06 +01002034 " - try to create new SPOE appctx\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002035 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
2036 ctx->strm);
2037
Christopher Fauleta1cda022016-12-21 08:58:06 +01002038 /* Do not try to create a new applet if there is no server up for the
2039 * agent's backend. */
2040 if (!agent->b.be->srv_act && !agent->b.be->srv_bck) {
2041 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2042 " - cannot create SPOE appctx: no server up\n",
2043 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2044 __FUNCTION__, ctx->strm);
2045 goto end;
2046 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002047
Christopher Fauleta1cda022016-12-21 08:58:06 +01002048 /* Do not try to create a new applet if we have reached the maximum of
2049 * connection per seconds */
Christopher Faulet48026722016-11-16 15:01:12 +01002050 if (agent->cps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002051 if (!freq_ctr_remain(&agent->rt[tid].conn_per_sec, agent->cps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002052 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2053 " - cannot create SPOE appctx: max CPS reached\n",
2054 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2055 __FUNCTION__, ctx->strm);
2056 goto end;
2057 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002058 }
2059
Christopher Faulet8ef75252017-02-20 22:56:03 +01002060 appctx = spoe_create_appctx(conf);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002061 if (appctx == NULL) {
2062 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2063 " - failed to create SPOE appctx\n",
2064 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2065 __FUNCTION__, ctx->strm);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02002066 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01002067 "SPOE: [%s] failed to create SPOE applet\n",
2068 agent->id);
2069
Christopher Fauleta1cda022016-12-21 08:58:06 +01002070 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002071 }
2072
Christopher Fauleta1cda022016-12-21 08:58:06 +01002073 /* Increase the per-process number of cumulated connections */
2074 if (agent->cps_max > 0)
Christopher Faulet24289f22017-09-25 14:48:02 +02002075 update_freq_ctr(&agent->rt[tid].conn_per_sec, 1);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002076
Christopher Fauleta1cda022016-12-21 08:58:06 +01002077 end:
2078 /* The only reason to return an error is when there is no applet */
Christopher Faulet24289f22017-09-25 14:48:02 +02002079 if (LIST_ISEMPTY(&agent->rt[tid].applets)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002080 ctx->status_code = SPOE_CTX_ERR_RES;
2081 return -1;
2082 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002083
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002084 /* Add the SPOE context in the sending queue if the stream has no applet
2085 * already assigned and wakeup all idle applets. Otherwise, don't queue
2086 * it. */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002087 _HA_ATOMIC_ADD(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002088 spoe_update_stat_time(&ctx->stats.tv_request, &ctx->stats.t_request);
2089 ctx->stats.tv_queue = now;
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002090 if (ctx->spoe_appctx)
2091 return 1;
2092 LIST_ADDQ(&agent->rt[tid].sending_queue, &ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002093
2094 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002095 " - Add stream in sending queue"
Christopher Faulet68db0232018-04-06 11:34:12 +02002096 " - applets=%u - idles=%u - processing=%u\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002097 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
Christopher Faulet68db0232018-04-06 11:34:12 +02002098 ctx->strm, agent->counters.applets, agent->counters.idles,
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002099 agent->rt[tid].processing);
Christopher Fauletf7a30922016-11-10 15:04:51 +01002100
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002101 /* Finally try to wakeup an IDLE applet. */
2102 if (!eb_is_empty(&agent->rt[tid].idle_applets)) {
2103 struct eb32_node *node;
2104
2105 node = eb32_first(&agent->rt[tid].idle_applets);
2106 spoe_appctx = eb32_entry(node, struct spoe_appctx, node);
2107 if (node && spoe_appctx) {
2108 eb32_delete(&spoe_appctx->node);
2109 spoe_appctx->node.key++;
2110 eb32_insert(&agent->rt[tid].idle_applets, &spoe_appctx->node);
2111 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002112 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002113 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002114 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002115}
2116
2117/***************************************************************************
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002118 * Functions that encode SPOE messages
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002119 **************************************************************************/
Christopher Faulet10e37672017-09-21 16:38:22 +02002120/* Encode a SPOE message. Info in <ctx->frag_ctx>, if any, are used to handle
2121 * fragmented_content. If the next message can be processed, it returns 0. If
2122 * the message is too big, it returns -1.*/
2123static int
2124spoe_encode_message(struct stream *s, struct spoe_context *ctx,
2125 struct spoe_message *msg, int dir,
2126 char **buf, char *end)
2127{
2128 struct sample *smp;
2129 struct spoe_arg *arg;
2130 int ret;
2131
2132 if (msg->cond) {
2133 ret = acl_exec_cond(msg->cond, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2134 ret = acl_pass(ret);
2135 if (msg->cond->pol == ACL_COND_UNLESS)
2136 ret = !ret;
2137
2138 /* the rule does not match */
2139 if (!ret)
2140 goto next;
2141 }
2142
2143 /* Resume encoding of a SPOE argument */
2144 if (ctx->frag_ctx.curarg != NULL) {
2145 arg = ctx->frag_ctx.curarg;
2146 goto encode_argument;
2147 }
2148
2149 if (ctx->frag_ctx.curoff != UINT_MAX)
2150 goto encode_msg_payload;
2151
2152 /* Check if there is enough space for the message name and the
2153 * number of arguments. It implies <msg->id_len> is encoded on 2
2154 * bytes, at most (< 2288). */
2155 if (*buf + 2 + msg->id_len + 1 > end)
2156 goto too_big;
2157
2158 /* Encode the message name */
2159 if (spoe_encode_buffer(msg->id, msg->id_len, buf, end) == -1)
2160 goto too_big;
2161
2162 /* Set the number of arguments for this message */
2163 **buf = msg->nargs;
2164 (*buf)++;
2165
2166 ctx->frag_ctx.curoff = 0;
2167 encode_msg_payload:
2168
2169 /* Loop on arguments */
2170 list_for_each_entry(arg, &msg->args, list) {
2171 ctx->frag_ctx.curarg = arg;
2172 ctx->frag_ctx.curoff = UINT_MAX;
Kevin Zhuf7f54282019-04-26 14:00:01 +08002173 ctx->frag_ctx.curlen = 0;
Christopher Faulet10e37672017-09-21 16:38:22 +02002174
2175 encode_argument:
2176 if (ctx->frag_ctx.curoff != UINT_MAX)
2177 goto encode_arg_value;
2178
Joseph Herlantf7f60312018-11-15 13:46:49 -08002179 /* Encode the argument name as a string. It can by NULL */
Christopher Faulet10e37672017-09-21 16:38:22 +02002180 if (spoe_encode_buffer(arg->name, arg->name_len, buf, end) == -1)
2181 goto too_big;
2182
2183 ctx->frag_ctx.curoff = 0;
2184 encode_arg_value:
2185
Joseph Herlantf7f60312018-11-15 13:46:49 -08002186 /* Fetch the argument value */
Christopher Faulet10e37672017-09-21 16:38:22 +02002187 smp = sample_process(s->be, s->sess, s, dir|SMP_OPT_FINAL, arg->expr, NULL);
Christopher Faulet3b1d0042019-05-06 09:53:10 +02002188 if (smp) {
2189 smp->ctx.a[0] = &ctx->frag_ctx.curlen;
2190 smp->ctx.a[1] = &ctx->frag_ctx.curoff;
2191 }
Christopher Faulet85db3212019-04-26 14:30:15 +02002192 ret = spoe_encode_data(smp, buf, end);
Christopher Faulet10e37672017-09-21 16:38:22 +02002193 if (ret == -1 || ctx->frag_ctx.curoff)
2194 goto too_big;
2195 }
2196
2197 next:
2198 return 0;
2199
2200 too_big:
2201 return -1;
2202}
2203
Christopher Fauletc718b822017-09-21 16:50:56 +02002204/* Encode list of SPOE messages. Info in <ctx->frag_ctx>, if any, are used to
2205 * handle fragmented content. On success it returns 1. If an error occurred, -1
2206 * is returned. If nothing has been encoded, it returns 0 (this is only possible
2207 * for unfragmented payload). */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002208static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002209spoe_encode_messages(struct stream *s, struct spoe_context *ctx,
Christopher Fauletc718b822017-09-21 16:50:56 +02002210 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002211{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002212 struct spoe_config *conf = FLT_CONF(ctx->filter);
2213 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002214 struct spoe_message *msg;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002215 char *p, *end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002216
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002217 p = b_head(&ctx->buffer);
Christopher Faulet24289f22017-09-25 14:48:02 +02002218 end = p + agent->rt[tid].frame_size - FRAME_HDR_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002219
Christopher Fauletc718b822017-09-21 16:50:56 +02002220 if (type == SPOE_MSGS_BY_EVENT) { /* Loop on messages by event */
2221 /* Resume encoding of a SPOE message */
2222 if (ctx->frag_ctx.curmsg != NULL) {
2223 msg = ctx->frag_ctx.curmsg;
2224 goto encode_evt_message;
2225 }
2226
2227 list_for_each_entry(msg, messages, by_evt) {
2228 ctx->frag_ctx.curmsg = msg;
2229 ctx->frag_ctx.curarg = NULL;
2230 ctx->frag_ctx.curoff = UINT_MAX;
2231
2232 encode_evt_message:
2233 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2234 goto too_big;
2235 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002236 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002237 else if (type == SPOE_MSGS_BY_GROUP) { /* Loop on messages by group */
2238 /* Resume encoding of a SPOE message */
2239 if (ctx->frag_ctx.curmsg != NULL) {
2240 msg = ctx->frag_ctx.curmsg;
2241 goto encode_grp_message;
2242 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002243
Christopher Fauletc718b822017-09-21 16:50:56 +02002244 list_for_each_entry(msg, messages, by_grp) {
2245 ctx->frag_ctx.curmsg = msg;
2246 ctx->frag_ctx.curarg = NULL;
2247 ctx->frag_ctx.curoff = UINT_MAX;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002248
Christopher Fauletc718b822017-09-21 16:50:56 +02002249 encode_grp_message:
2250 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2251 goto too_big;
2252 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002253 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002254 else
2255 goto skip;
2256
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002257
Christopher Faulet57583e42017-09-04 15:41:09 +02002258 /* nothing has been encoded for an unfragmented payload */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002259 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) && p == b_head(&ctx->buffer))
Christopher Faulet57583e42017-09-04 15:41:09 +02002260 goto skip;
2261
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002262 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002263 " - encode %s messages - spoe_appctx=%p"
2264 "- max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002265 (int)now.tv_sec, (int)now.tv_usec,
2266 agent->id, __FUNCTION__, s,
2267 ((ctx->flags & SPOE_CTX_FL_FRAGMENTED) ? "last fragment of" : "unfragmented"),
Christopher Fauletfce747b2018-01-24 15:59:32 +01002268 ctx->spoe_appctx, (agent->rt[tid].frame_size - FRAME_HDR_SIZE),
Christopher Faulet45073512018-07-20 10:16:29 +02002269 p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002270
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002271 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002272 ctx->frag_ctx.curmsg = NULL;
2273 ctx->frag_ctx.curarg = NULL;
2274 ctx->frag_ctx.curoff = 0;
2275 ctx->frag_ctx.flags = SPOE_FRM_FL_FIN;
Christopher Faulet57583e42017-09-04 15:41:09 +02002276
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002277 return 1;
2278
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002279 too_big:
Christopher Fauleta715ea82019-04-10 14:21:51 +02002280 /* Return an error if fragmentation is unsupported or if nothing has
2281 * been encoded because its too big and not splittable. */
2282 if (!(agent->flags & SPOE_FL_SND_FRAGMENTATION) || p == b_head(&ctx->buffer)) {
Christopher Fauletcecd8522017-02-24 22:11:21 +01002283 ctx->status_code = SPOE_CTX_ERR_TOO_BIG;
2284 return -1;
2285 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002286
2287 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002288 " - encode fragmented messages - spoe_appctx=%p"
2289 " - curmsg=%p - curarg=%p - curoff=%u"
2290 " - max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002291 (int)now.tv_sec, (int)now.tv_usec,
Christopher Fauletfce747b2018-01-24 15:59:32 +01002292 agent->id, __FUNCTION__, s, ctx->spoe_appctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002293 ctx->frag_ctx.curmsg, ctx->frag_ctx.curarg, ctx->frag_ctx.curoff,
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002294 (agent->rt[tid].frame_size - FRAME_HDR_SIZE), p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002295
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002296 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002297 ctx->flags |= SPOE_CTX_FL_FRAGMENTED;
2298 ctx->frag_ctx.flags &= ~SPOE_FRM_FL_FIN;
2299 return 1;
Christopher Faulet57583e42017-09-04 15:41:09 +02002300
2301 skip:
2302 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2303 " - skip the frame because nothing has been encoded\n",
2304 (int)now.tv_sec, (int)now.tv_usec,
2305 agent->id, __FUNCTION__, s);
2306 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002307}
2308
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002309
2310/***************************************************************************
2311 * Functions that handle SPOE actions
2312 **************************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002313/* Helper function to set a variable */
2314static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002315spoe_set_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002316 struct sample *smp)
2317{
2318 struct spoe_config *conf = FLT_CONF(ctx->filter);
2319 struct spoe_agent *agent = conf->agent;
2320 char varname[64];
2321
2322 memset(varname, 0, sizeof(varname));
2323 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2324 scope, agent->var_pfx, len, name);
Etienne Carriereaec89892017-12-14 09:36:40 +00002325 if (agent->flags & SPOE_FL_FORCE_SET_VAR)
2326 vars_set_by_name(varname, len, smp);
2327 else
2328 vars_set_by_name_ifexist(varname, len, smp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002329}
2330
2331/* Helper function to unset a variable */
2332static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002333spoe_unset_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002334 struct sample *smp)
2335{
2336 struct spoe_config *conf = FLT_CONF(ctx->filter);
2337 struct spoe_agent *agent = conf->agent;
2338 char varname[64];
2339
2340 memset(varname, 0, sizeof(varname));
2341 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2342 scope, agent->var_pfx, len, name);
2343 vars_unset_by_name_ifexist(varname, len, smp);
2344}
2345
2346
Christopher Faulet8ef75252017-02-20 22:56:03 +01002347static inline int
2348spoe_decode_action_set_var(struct stream *s, struct spoe_context *ctx,
2349 char **buf, char *end, int dir)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002350{
Christopher Faulet8ef75252017-02-20 22:56:03 +01002351 char *str, *scope, *p = *buf;
2352 struct sample smp;
2353 uint64_t sz;
2354 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002355
Christopher Faulet8ef75252017-02-20 22:56:03 +01002356 if (p + 2 >= end)
2357 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002358
Christopher Faulet8ef75252017-02-20 22:56:03 +01002359 /* SET-VAR requires 3 arguments */
2360 if (*p++ != 3)
2361 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002362
Christopher Faulet8ef75252017-02-20 22:56:03 +01002363 switch (*p++) {
2364 case SPOE_SCOPE_PROC: scope = "proc"; break;
2365 case SPOE_SCOPE_SESS: scope = "sess"; break;
2366 case SPOE_SCOPE_TXN : scope = "txn"; break;
2367 case SPOE_SCOPE_REQ : scope = "req"; break;
2368 case SPOE_SCOPE_RES : scope = "res"; break;
2369 default: goto skip;
2370 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002371
Christopher Faulet8ef75252017-02-20 22:56:03 +01002372 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2373 goto skip;
2374 memset(&smp, 0, sizeof(smp));
2375 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002376
Christopher Faulet8ef75252017-02-20 22:56:03 +01002377 if (spoe_decode_data(&p, end, &smp) == -1)
2378 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002379
Christopher Faulet8ef75252017-02-20 22:56:03 +01002380 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2381 " - set-var '%s.%s.%.*s'\n",
2382 (int)now.tv_sec, (int)now.tv_usec,
2383 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2384 __FUNCTION__, s, scope,
2385 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2386 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002387
Christopher Faulet2469eba2020-10-15 16:08:30 +02002388 if (smp.data.type == SMP_T_ANY)
2389 spoe_unset_var(ctx, scope, str, sz, &smp);
2390 else
2391 spoe_set_var(ctx, scope, str, sz, &smp);
Christopher Fauletb5cff602016-11-24 14:53:22 +01002392
Christopher Faulet8ef75252017-02-20 22:56:03 +01002393 ret = (p - *buf);
2394 *buf = p;
2395 return ret;
2396 skip:
2397 return 0;
2398}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002399
Christopher Faulet8ef75252017-02-20 22:56:03 +01002400static inline int
2401spoe_decode_action_unset_var(struct stream *s, struct spoe_context *ctx,
2402 char **buf, char *end, int dir)
2403{
2404 char *str, *scope, *p = *buf;
2405 struct sample smp;
2406 uint64_t sz;
2407 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002408
Christopher Faulet8ef75252017-02-20 22:56:03 +01002409 if (p + 2 >= end)
2410 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002411
Christopher Faulet8ef75252017-02-20 22:56:03 +01002412 /* UNSET-VAR requires 2 arguments */
2413 if (*p++ != 2)
2414 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002415
Christopher Faulet8ef75252017-02-20 22:56:03 +01002416 switch (*p++) {
2417 case SPOE_SCOPE_PROC: scope = "proc"; break;
2418 case SPOE_SCOPE_SESS: scope = "sess"; break;
2419 case SPOE_SCOPE_TXN : scope = "txn"; break;
2420 case SPOE_SCOPE_REQ : scope = "req"; break;
2421 case SPOE_SCOPE_RES : scope = "res"; break;
2422 default: goto skip;
2423 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002424
Christopher Faulet8ef75252017-02-20 22:56:03 +01002425 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2426 goto skip;
2427 memset(&smp, 0, sizeof(smp));
2428 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002429
Christopher Faulet8ef75252017-02-20 22:56:03 +01002430 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2431 " - unset-var '%s.%s.%.*s'\n",
2432 (int)now.tv_sec, (int)now.tv_usec,
2433 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2434 __FUNCTION__, s, scope,
2435 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2436 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002437
Christopher Faulet8ef75252017-02-20 22:56:03 +01002438 spoe_unset_var(ctx, scope, str, sz, &smp);
2439
2440 ret = (p - *buf);
2441 *buf = p;
2442 return ret;
2443 skip:
2444 return 0;
2445}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002446
Christopher Faulet8ef75252017-02-20 22:56:03 +01002447/* Process SPOE actions for a specific event. It returns 1 on success. If an
2448 * error occurred, 0 is returned. */
2449static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002450spoe_process_actions(struct stream *s, struct spoe_context *ctx, int dir)
Christopher Faulet8ef75252017-02-20 22:56:03 +01002451{
2452 char *p, *end;
2453 int ret;
2454
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002455 p = b_head(&ctx->buffer);
2456 end = p + b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002457
2458 while (p < end) {
2459 enum spoe_action_type type;
2460
2461 type = *p++;
2462 switch (type) {
2463 case SPOE_ACT_T_SET_VAR:
2464 ret = spoe_decode_action_set_var(s, ctx, &p, end, dir);
2465 if (!ret)
2466 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002467 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002468
Christopher Faulet8ef75252017-02-20 22:56:03 +01002469 case SPOE_ACT_T_UNSET_VAR:
2470 ret = spoe_decode_action_unset_var(s, ctx, &p, end, dir);
2471 if (!ret)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002472 goto skip;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002473 break;
2474
2475 default:
2476 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002477 }
2478 }
2479
2480 return 1;
2481 skip:
2482 return 0;
2483}
2484
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002485/***************************************************************************
2486 * Functions that process SPOE events
2487 **************************************************************************/
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002488static void
2489spoe_update_stats(struct stream *s, struct spoe_agent *agent,
2490 struct spoe_context *ctx, int dir)
2491{
2492 if (!tv_iszero(&ctx->stats.tv_start)) {
2493 spoe_update_stat_time(&ctx->stats.tv_start, &ctx->stats.t_process);
2494 ctx->stats.t_total += ctx->stats.t_process;
2495 tv_zero(&ctx->stats.tv_request);
2496 tv_zero(&ctx->stats.tv_queue);
2497 tv_zero(&ctx->stats.tv_wait);
2498 tv_zero(&ctx->stats.tv_response);
2499 }
2500
2501 if (agent->var_t_process) {
2502 struct sample smp;
2503
2504 memset(&smp, 0, sizeof(smp));
2505 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2506 smp.data.u.sint = ctx->stats.t_process;
2507 smp.data.type = SMP_T_SINT;
2508
2509 spoe_set_var(ctx, "txn", agent->var_t_process,
2510 strlen(agent->var_t_process), &smp);
2511 }
2512
2513 if (agent->var_t_total) {
2514 struct sample smp;
2515
2516 memset(&smp, 0, sizeof(smp));
2517 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2518 smp.data.u.sint = ctx->stats.t_total;
2519 smp.data.type = SMP_T_SINT;
2520
2521 spoe_set_var(ctx, "txn", agent->var_t_total,
2522 strlen(agent->var_t_total), &smp);
2523 }
2524}
2525
2526static void
2527spoe_handle_processing_error(struct stream *s, struct spoe_agent *agent,
2528 struct spoe_context *ctx, int dir)
2529{
2530 if (agent->eps_max > 0)
2531 update_freq_ctr(&agent->rt[tid].err_per_sec, 1);
2532
2533 if (agent->var_on_error) {
2534 struct sample smp;
2535
2536 memset(&smp, 0, sizeof(smp));
2537 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2538 smp.data.u.sint = ctx->status_code;
2539 smp.data.type = SMP_T_BOOL;
2540
2541 spoe_set_var(ctx, "txn", agent->var_on_error,
2542 strlen(agent->var_on_error), &smp);
2543 }
2544
2545 ctx->state = ((agent->flags & SPOE_FL_CONT_ON_ERR)
2546 ? SPOE_CTX_ST_READY
2547 : SPOE_CTX_ST_NONE);
2548}
2549
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002550static inline int
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002551spoe_start_processing(struct spoe_agent *agent, struct spoe_context *ctx, int dir)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002552{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002553 /* If a process is already started for this SPOE context, retry
2554 * later. */
2555 if (ctx->flags & SPOE_CTX_FL_PROCESS)
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002556 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002557
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002558 agent->rt[tid].processing++;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002559 ctx->stats.tv_start = now;
2560 ctx->stats.tv_request = now;
2561 ctx->stats.t_request = -1;
2562 ctx->stats.t_queue = -1;
2563 ctx->stats.t_waiting = -1;
2564 ctx->stats.t_response = -1;
2565 ctx->stats.t_process = -1;
2566
2567 ctx->status_code = 0;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002568
Christopher Fauleta1cda022016-12-21 08:58:06 +01002569 /* Set the right flag to prevent request and response processing
2570 * in same time. */
2571 ctx->flags |= ((dir == SMP_OPT_DIR_REQ)
2572 ? SPOE_CTX_FL_REQ_PROCESS
2573 : SPOE_CTX_FL_RSP_PROCESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002574 return 1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002575}
2576
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002577static inline void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002578spoe_stop_processing(struct spoe_agent *agent, struct spoe_context *ctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002579{
Christopher Fauletfce747b2018-01-24 15:59:32 +01002580 struct spoe_appctx *sa = ctx->spoe_appctx;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002581
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002582 if (!(ctx->flags & SPOE_CTX_FL_PROCESS))
2583 return;
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002584 _HA_ATOMIC_ADD(&agent->counters.nb_processed, 1);
Christopher Faulet879dca92018-03-23 11:53:24 +01002585 if (sa) {
2586 if (sa->frag_ctx.ctx == ctx) {
2587 sa->frag_ctx.ctx = NULL;
2588 spoe_wakeup_appctx(sa->owner);
2589 }
2590 else
2591 sa->cur_fpa--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002592 }
2593
Christopher Fauleta1cda022016-12-21 08:58:06 +01002594 /* Reset the flag to allow next processing */
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002595 agent->rt[tid].processing--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002596 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002597
2598 /* Reset processing timer */
2599 ctx->process_exp = TICK_ETERNITY;
2600
Christopher Faulet8ef75252017-02-20 22:56:03 +01002601 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002602
Christopher Fauletfce747b2018-01-24 15:59:32 +01002603 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002604 ctx->frag_ctx.curmsg = NULL;
2605 ctx->frag_ctx.curarg = NULL;
2606 ctx->frag_ctx.curoff = 0;
2607 ctx->frag_ctx.flags = 0;
2608
Christopher Fauleta1cda022016-12-21 08:58:06 +01002609 if (!LIST_ISEMPTY(&ctx->list)) {
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002610 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS)
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002611 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002612 else
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002613 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002614
Christopher Fauleta1cda022016-12-21 08:58:06 +01002615 LIST_DEL(&ctx->list);
2616 LIST_INIT(&ctx->list);
2617 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002618}
2619
Christopher Faulet58d03682017-09-21 16:57:24 +02002620/* Process a list of SPOE messages. First, this functions will process messages
2621 * and send them to an agent in a NOTIFY frame. Then, it will wait a ACK frame
2622 * to process corresponding actions. During all the processing, it returns 0
2623 * and it returns 1 when the processing is finished. If an error occurred, -1
2624 * is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002625static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002626spoe_process_messages(struct stream *s, struct spoe_context *ctx,
2627 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002628{
Christopher Fauletf7a30922016-11-10 15:04:51 +01002629 struct spoe_config *conf = FLT_CONF(ctx->filter);
2630 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002631 int ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002632
2633 if (ctx->state == SPOE_CTX_ST_ERROR)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002634 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002635
2636 if (tick_is_expired(ctx->process_exp, now_ms) && ctx->state != SPOE_CTX_ST_DONE) {
2637 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002638 " - failed to process messages: timeout\n",
Christopher Fauletf7a30922016-11-10 15:04:51 +01002639 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002640 agent->id, __FUNCTION__, s);
Christopher Fauletb067b062017-01-04 16:39:11 +01002641 ctx->status_code = SPOE_CTX_ERR_TOUT;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002642 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002643 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002644
2645 if (ctx->state == SPOE_CTX_ST_READY) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002646 if (agent->eps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002647 if (!freq_ctr_remain(&agent->rt[tid].err_per_sec, agent->eps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002648 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002649 " - skip processing of messages: max EPS reached\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002650 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002651 agent->id, __FUNCTION__, s);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002652 goto skip;
2653 }
2654 }
2655
Christopher Fauletf7a30922016-11-10 15:04:51 +01002656 if (!tick_isset(ctx->process_exp)) {
2657 ctx->process_exp = tick_add_ifset(now_ms, agent->timeout.processing);
2658 s->task->expire = tick_first((tick_is_expired(s->task->expire, now_ms) ? 0 : s->task->expire),
2659 ctx->process_exp);
2660 }
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002661 ret = spoe_start_processing(agent, ctx, dir);
Christopher Fauletb067b062017-01-04 16:39:11 +01002662 if (!ret)
2663 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002664
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002665 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002666 /* fall through */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002667 }
2668
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002669 if (ctx->state == SPOE_CTX_ST_ENCODING_MSGS) {
Christopher Faulet63263e52019-04-10 14:47:18 +02002670 if (tv_iszero(&ctx->stats.tv_request))
2671 ctx->stats.tv_request = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002672 if (!spoe_acquire_buffer(&ctx->buffer, &ctx->buffer_wait))
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002673 goto out;
Christopher Faulet58d03682017-09-21 16:57:24 +02002674 ret = spoe_encode_messages(s, ctx, messages, dir, type);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002675 if (ret < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002676 goto end;
Christopher Faulet57583e42017-09-04 15:41:09 +02002677 if (!ret)
2678 goto skip;
Christopher Faulet333694d2018-01-12 10:45:47 +01002679 if (spoe_queue_context(ctx) < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002680 goto end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002681 ctx->state = SPOE_CTX_ST_SENDING_MSGS;
2682 }
2683
2684 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS) {
Christopher Fauletfce747b2018-01-24 15:59:32 +01002685 if (ctx->spoe_appctx)
2686 spoe_wakeup_appctx(ctx->spoe_appctx->owner);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002687 ret = 0;
2688 goto out;
2689 }
2690
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002691 if (ctx->state == SPOE_CTX_ST_WAITING_ACK) {
2692 ret = 0;
2693 goto out;
2694 }
2695
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002696 if (ctx->state == SPOE_CTX_ST_DONE) {
Christopher Faulet58d03682017-09-21 16:57:24 +02002697 spoe_process_actions(s, ctx, dir);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002698 ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002699 ctx->frame_id++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002700 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002701 spoe_update_stat_time(&ctx->stats.tv_response, &ctx->stats.t_response);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002702 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002703 }
2704
2705 out:
2706 return ret;
2707
Christopher Fauleta1cda022016-12-21 08:58:06 +01002708 skip:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002709 tv_zero(&ctx->stats.tv_start);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002710 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002711 spoe_stop_processing(agent, ctx);
2712 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002713
Christopher Fauleta1cda022016-12-21 08:58:06 +01002714 end:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002715 spoe_update_stats(s, agent, ctx, dir);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002716 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002717 if (ctx->status_code) {
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002718 _HA_ATOMIC_ADD(&agent->counters.nb_errors, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002719 spoe_handle_processing_error(s, agent, ctx, dir);
2720 ret = 1;
2721 }
Christopher Faulet58d03682017-09-21 16:57:24 +02002722 return ret;
2723}
2724
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002725/* Process a SPOE group, ie the list of messages attached to the group <grp>.
2726 * See spoe_process_message for details. */
2727static int
2728spoe_process_group(struct stream *s, struct spoe_context *ctx,
2729 struct spoe_group *group, int dir)
2730{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002731 struct spoe_config *conf = FLT_CONF(ctx->filter);
2732 struct spoe_agent *agent = conf->agent;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002733 int ret;
2734
2735 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2736 " - ctx-state=%s - Process messages for group=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002737 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002738 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2739 group->id);
2740
2741 if (LIST_ISEMPTY(&group->messages))
2742 return 1;
2743
2744 ret = spoe_process_messages(s, ctx, &group->messages, dir, SPOE_MSGS_BY_GROUP);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002745 if (ret && ctx->stats.t_process != -1) {
2746 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002747 " - <GROUP:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu %u/%u\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002748 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002749 __FUNCTION__, s, group->id, s->uniq_id, ctx->status_code,
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002750 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002751 ctx->stats.t_response, ctx->stats.t_process,
2752 agent->counters.idles, agent->counters.applets,
2753 agent->counters.nb_sending, agent->counters.nb_waiting,
2754 agent->counters.nb_errors, agent->counters.nb_processed,
2755 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2756 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2757 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2758 "SPOE: [%s] <GROUP:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2759 agent->id, group->id, s->uniq_id, ctx->status_code,
2760 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2761 ctx->stats.t_response, ctx->stats.t_process,
2762 agent->counters.idles, agent->counters.applets,
2763 agent->counters.nb_sending, agent->counters.nb_waiting,
2764 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002765 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002766 return ret;
2767}
2768
Christopher Faulet58d03682017-09-21 16:57:24 +02002769/* Process a SPOE event, ie the list of messages attached to the event <ev>.
2770 * See spoe_process_message for details. */
2771static int
2772spoe_process_event(struct stream *s, struct spoe_context *ctx,
2773 enum spoe_event ev)
2774{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002775 struct spoe_config *conf = FLT_CONF(ctx->filter);
2776 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002777 int dir, ret;
2778
2779 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002780 " - ctx-state=%s - Process messages for event=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002781 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet58d03682017-09-21 16:57:24 +02002782 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2783 spoe_event_str[ev]);
2784
2785 dir = ((ev < SPOE_EV_ON_SERVER_SESS) ? SMP_OPT_DIR_REQ : SMP_OPT_DIR_RES);
2786
2787 if (LIST_ISEMPTY(&(ctx->events[ev])))
2788 return 1;
2789
2790 ret = spoe_process_messages(s, ctx, &(ctx->events[ev]), dir, SPOE_MSGS_BY_EVENT);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002791 if (ret && ctx->stats.t_process != -1) {
2792 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002793 " - <EVENT:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu %u/%u\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002794 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2795 __FUNCTION__, s, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2796 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002797 ctx->stats.t_response, ctx->stats.t_process,
2798 agent->counters.idles, agent->counters.applets,
2799 agent->counters.nb_sending, agent->counters.nb_waiting,
2800 agent->counters.nb_errors, agent->counters.nb_processed,
2801 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2802 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2803 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2804 "SPOE: [%s] <EVENT:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2805 agent->id, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2806 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2807 ctx->stats.t_response, ctx->stats.t_process,
2808 agent->counters.idles, agent->counters.applets,
2809 agent->counters.nb_sending, agent->counters.nb_waiting,
2810 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002811 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002812 return ret;
2813}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002814
2815/***************************************************************************
2816 * Functions that create/destroy SPOE contexts
2817 **************************************************************************/
Christopher Fauleta1cda022016-12-21 08:58:06 +01002818static int
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002819spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002820{
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002821 if (buf->size)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002822 return 1;
2823
Willy Tarreau21046592020-02-26 10:39:36 +01002824 if (MT_LIST_ADDED(&buffer_wait->list))
2825 MT_LIST_DEL(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002826
Christopher Faulet4596fb72017-01-11 14:05:19 +01002827 if (b_alloc_margin(buf, global.tune.reserved_bufs))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002828 return 1;
2829
Willy Tarreau86891272020-07-10 08:22:26 +02002830 MT_LIST_ADDQ(&buffer_wq, &buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002831 return 0;
2832}
2833
2834static void
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002835spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002836{
Willy Tarreau21046592020-02-26 10:39:36 +01002837 if (MT_LIST_ADDED(&buffer_wait->list))
2838 MT_LIST_DEL(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002839
2840 /* Release the buffer if needed */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002841 if (buf->size) {
Christopher Faulet4596fb72017-01-11 14:05:19 +01002842 b_free(buf);
Olivier Houchard673867c2018-05-25 16:58:52 +02002843 offer_buffers(buffer_wait->target, tasks_run_queue);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002844 }
2845}
2846
Christopher Faulet4596fb72017-01-11 14:05:19 +01002847static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002848spoe_wakeup_context(struct spoe_context *ctx)
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002849{
2850 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
2851 return 1;
2852}
2853
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002854static struct spoe_context *
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002855spoe_create_context(struct stream *s, struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002856{
2857 struct spoe_config *conf = FLT_CONF(filter);
2858 struct spoe_context *ctx;
2859
Willy Tarreaubafbe012017-11-24 17:34:44 +01002860 ctx = pool_alloc_dirty(pool_head_spoe_ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002861 if (ctx == NULL) {
2862 return NULL;
2863 }
2864 memset(ctx, 0, sizeof(*ctx));
Christopher Fauletb067b062017-01-04 16:39:11 +01002865 ctx->filter = filter;
2866 ctx->state = SPOE_CTX_ST_NONE;
2867 ctx->status_code = SPOE_CTX_ERR_NONE;
2868 ctx->flags = 0;
Christopher Faulet11610f32017-09-21 10:23:10 +02002869 ctx->events = conf->agent->events;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02002870 ctx->groups = &conf->agent->groups;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002871 ctx->buffer = BUF_NULL;
Willy Tarreau21046592020-02-26 10:39:36 +01002872 MT_LIST_INIT(&ctx->buffer_wait.list);
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002873 ctx->buffer_wait.target = ctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002874 ctx->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_context;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002875 LIST_INIT(&ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002876
Christopher Fauletf7a30922016-11-10 15:04:51 +01002877 ctx->stream_id = 0;
2878 ctx->frame_id = 1;
2879 ctx->process_exp = TICK_ETERNITY;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002880
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002881 tv_zero(&ctx->stats.tv_start);
2882 tv_zero(&ctx->stats.tv_request);
2883 tv_zero(&ctx->stats.tv_queue);
2884 tv_zero(&ctx->stats.tv_wait);
2885 tv_zero(&ctx->stats.tv_response);
2886 ctx->stats.t_request = -1;
2887 ctx->stats.t_queue = -1;
2888 ctx->stats.t_waiting = -1;
2889 ctx->stats.t_response = -1;
2890 ctx->stats.t_process = -1;
2891 ctx->stats.t_total = 0;
2892
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002893 ctx->strm = s;
2894 ctx->state = SPOE_CTX_ST_READY;
2895 filter->ctx = ctx;
2896
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002897 return ctx;
2898}
2899
2900static void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002901spoe_destroy_context(struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002902{
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002903 struct spoe_config *conf = FLT_CONF(filter);
2904 struct spoe_context *ctx = filter->ctx;
2905
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002906 if (!ctx)
2907 return;
2908
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002909 spoe_stop_processing(conf->agent, ctx);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002910 pool_free(pool_head_spoe_ctx, ctx);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002911 filter->ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002912}
2913
2914static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002915spoe_reset_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002916{
2917 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01002918 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002919
2920 tv_zero(&ctx->stats.tv_start);
2921 tv_zero(&ctx->stats.tv_request);
2922 tv_zero(&ctx->stats.tv_queue);
2923 tv_zero(&ctx->stats.tv_wait);
2924 tv_zero(&ctx->stats.tv_response);
2925 ctx->stats.t_request = -1;
2926 ctx->stats.t_queue = -1;
2927 ctx->stats.t_waiting = -1;
2928 ctx->stats.t_response = -1;
2929 ctx->stats.t_process = -1;
2930 ctx->stats.t_total = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002931}
2932
2933
2934/***************************************************************************
2935 * Hooks that manage the filter lifecycle (init/check/deinit)
2936 **************************************************************************/
2937/* Signal handler: Do a soft stop, wakeup SPOE applet */
2938static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002939spoe_sig_stop(struct sig_handler *sh)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002940{
2941 struct proxy *p;
2942
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002943 p = proxies_list;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002944 while (p) {
2945 struct flt_conf *fconf;
2946
2947 list_for_each_entry(fconf, &p->filter_configs, list) {
Christopher Faulet3b386a32017-02-23 10:17:15 +01002948 struct spoe_config *conf;
2949 struct spoe_agent *agent;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002950 struct spoe_appctx *spoe_appctx;
Christopher Faulet24289f22017-09-25 14:48:02 +02002951 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002952
Christopher Faulet3b386a32017-02-23 10:17:15 +01002953 if (fconf->id != spoe_filter_id)
2954 continue;
2955
2956 conf = fconf->conf;
2957 agent = conf->agent;
2958
Christopher Faulet24289f22017-09-25 14:48:02 +02002959 for (i = 0; i < global.nbthread; ++i) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002960 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02002961 list_for_each_entry(spoe_appctx, &agent->rt[i].applets, list)
2962 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002963 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002964 }
2965 }
2966 p = p->next;
2967 }
2968}
2969
2970
2971/* Initialize the SPOE filter. Returns -1 on error, else 0. */
2972static int
2973spoe_init(struct proxy *px, struct flt_conf *fconf)
2974{
2975 struct spoe_config *conf = fconf->conf;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002976
Christopher Faulet7250b8f2018-03-26 17:19:01 +02002977 /* conf->agent_fe was already initialized during the config
2978 * parsing. Finish initialization. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002979 conf->agent_fe.last_change = now.tv_sec;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002980 conf->agent_fe.cap = PR_CAP_FE;
2981 conf->agent_fe.mode = PR_MODE_TCP;
2982 conf->agent_fe.maxconn = 0;
2983 conf->agent_fe.options2 |= PR_O2_INDEPSTR;
2984 conf->agent_fe.conn_retries = CONN_RETRIES;
2985 conf->agent_fe.accept = frontend_accept;
2986 conf->agent_fe.srv = NULL;
2987 conf->agent_fe.timeout.client = TICK_ETERNITY;
2988 conf->agent_fe.default_target = &spoe_applet.obj_type;
2989 conf->agent_fe.fe_req_ana = AN_REQ_SWITCHING_RULES;
2990
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002991 if (!sighandler_registered) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01002992 signal_register_fct(0, spoe_sig_stop, 0);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002993 sighandler_registered = 1;
2994 }
2995
Christopher Faulet00292352019-01-09 15:05:10 +01002996 fconf->flags |= FLT_CFG_FL_HTX;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002997 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002998}
2999
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003000/* Free resources allocated by the SPOE filter. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003001static void
3002spoe_deinit(struct proxy *px, struct flt_conf *fconf)
3003{
3004 struct spoe_config *conf = fconf->conf;
3005
3006 if (conf) {
3007 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003008
Christopher Faulet8ef75252017-02-20 22:56:03 +01003009 spoe_release_agent(agent);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003010 free(conf->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003011 free(conf);
3012 }
3013 fconf->conf = NULL;
3014}
3015
3016/* Check configuration of a SPOE filter for a specified proxy.
3017 * Return 1 on error, else 0. */
3018static int
3019spoe_check(struct proxy *px, struct flt_conf *fconf)
3020{
Christopher Faulet7ee86672017-09-19 11:08:28 +02003021 struct flt_conf *f;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003022 struct spoe_config *conf = fconf->conf;
3023 struct proxy *target;
Willy Tarreaub0769b22019-02-07 13:40:33 +01003024 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003025
Christopher Faulet7ee86672017-09-19 11:08:28 +02003026 /* Check all SPOE filters for proxy <px> to be sure all SPOE agent names
3027 * are uniq */
3028 list_for_each_entry(f, &px->filter_configs, list) {
3029 struct spoe_config *c = f->conf;
3030
3031 /* This is not an SPOE filter */
3032 if (f->id != spoe_filter_id)
3033 continue;
3034 /* This is the current SPOE filter */
3035 if (f == fconf)
3036 continue;
3037
3038 /* Check engine Id. It should be uniq */
3039 if (!strcmp(conf->id, c->id)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003040 ha_alert("Proxy %s : duplicated name for SPOE engine '%s'.\n",
3041 px->id, conf->id);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003042 return 1;
3043 }
3044 }
3045
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003046 target = proxy_be_by_name(conf->agent->b.name);
3047 if (target == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003048 ha_alert("Proxy %s : unknown backend '%s' used by SPOE agent '%s'"
3049 " declared at %s:%d.\n",
3050 px->id, conf->agent->b.name, conf->agent->id,
3051 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003052 return 1;
3053 }
3054 if (target->mode != PR_MODE_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003055 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3056 " at %s:%d does not support HTTP mode.\n",
3057 px->id, target->id, conf->agent->id,
3058 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003059 return 1;
3060 }
3061
Willy Tarreau2bdcfde2019-02-05 13:37:19 +01003062 if (px->bind_proc & ~target->bind_proc) {
3063 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3064 " at %s:%d does not cover all of its processes.\n",
3065 px->id, target->id, conf->agent->id,
3066 conf->agent->conf.file, conf->agent->conf.line);
3067 return 1;
3068 }
3069
Christopher Fauletfe261552019-03-18 13:57:42 +01003070 if ((conf->agent->rt = calloc(global.nbthread, sizeof(*conf->agent->rt))) == NULL) {
Willy Tarreaub0769b22019-02-07 13:40:33 +01003071 ha_alert("Proxy %s : out of memory initializing SPOE agent '%s' declared at %s:%d.\n",
3072 px->id, conf->agent->id, conf->agent->conf.file, conf->agent->conf.line);
3073 return 1;
3074 }
3075 for (i = 0; i < global.nbthread; ++i) {
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003076 conf->agent->rt[i].engine_id = NULL;
Christopher Fauletfe261552019-03-18 13:57:42 +01003077 conf->agent->rt[i].frame_size = conf->agent->max_frame_size;
3078 conf->agent->rt[i].processing = 0;
3079 LIST_INIT(&conf->agent->rt[i].applets);
3080 LIST_INIT(&conf->agent->rt[i].sending_queue);
3081 LIST_INIT(&conf->agent->rt[i].waiting_queue);
3082 HA_SPIN_INIT(&conf->agent->rt[i].lock);
Willy Tarreaub0769b22019-02-07 13:40:33 +01003083 }
3084
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003085 free(conf->agent->b.name);
3086 conf->agent->b.name = NULL;
3087 conf->agent->b.be = target;
3088 return 0;
3089}
3090
Kevin Zhud87b1a52019-09-17 15:05:45 +02003091/* Initializes the SPOE filter for a proxy for a specific thread.
3092 * Returns a negative value if an error occurs. */
3093static int
3094spoe_init_per_thread(struct proxy *p, struct flt_conf *fconf)
3095{
3096 struct spoe_config *conf = fconf->conf;
3097 struct spoe_agent *agent = conf->agent;
3098
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003099 agent->rt[tid].engine_id = generate_pseudo_uuid();
3100 if (agent->rt[tid].engine_id == NULL)
3101 return -1;
Kevin Zhud87b1a52019-09-17 15:05:45 +02003102 return 0;
3103}
3104
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003105/**************************************************************************
3106 * Hooks attached to a stream
3107 *************************************************************************/
3108/* Called when a filter instance is created and attach to a stream. It creates
3109 * the context that will be used to process this stream. */
3110static int
3111spoe_start(struct stream *s, struct filter *filter)
3112{
Christopher Faulet72bcc472017-01-04 16:39:41 +01003113 struct spoe_config *conf = FLT_CONF(filter);
3114 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003115 struct spoe_context *ctx;
3116
3117 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
Christopher Faulet72bcc472017-01-04 16:39:41 +01003118 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003119 __FUNCTION__, s);
3120
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003121 if ((ctx = spoe_create_context(s, filter)) == NULL) {
Christopher Faulet72bcc472017-01-04 16:39:41 +01003122 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
3123 " - failed to create SPOE context\n",
3124 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletccbc3fd2017-09-15 11:51:18 +02003125 __FUNCTION__, s);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02003126 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01003127 "SPOE: [%s] failed to create SPOE context\n",
3128 agent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003129 return 0;
3130 }
3131
Christopher Faulet11610f32017-09-21 10:23:10 +02003132 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003133 filter->pre_analyzers |= AN_REQ_INSPECT_FE;
3134
Christopher Faulet11610f32017-09-21 10:23:10 +02003135 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003136 filter->pre_analyzers |= AN_REQ_INSPECT_BE;
3137
Christopher Faulet11610f32017-09-21 10:23:10 +02003138 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003139 filter->pre_analyzers |= AN_RES_INSPECT;
3140
Christopher Faulet11610f32017-09-21 10:23:10 +02003141 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003142 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_FE;
3143
Christopher Faulet11610f32017-09-21 10:23:10 +02003144 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003145 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_BE;
3146
Christopher Faulet11610f32017-09-21 10:23:10 +02003147 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003148 filter->pre_analyzers |= AN_RES_HTTP_PROCESS_FE;
3149
3150 return 1;
3151}
3152
3153/* Called when a filter instance is detached from a stream. It release the
3154 * attached SPOE context. */
3155static void
3156spoe_stop(struct stream *s, struct filter *filter)
3157{
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003158 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
3159 (int)now.tv_sec, (int)now.tv_usec,
3160 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3161 __FUNCTION__, s);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003162 spoe_destroy_context(filter);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003163}
3164
Christopher Fauletf7a30922016-11-10 15:04:51 +01003165
3166/*
3167 * Called when the stream is woken up because of expired timer.
3168 */
3169static void
3170spoe_check_timeouts(struct stream *s, struct filter *filter)
3171{
3172 struct spoe_context *ctx = filter->ctx;
3173
Christopher Fauletac580602018-03-20 16:09:20 +01003174 if (tick_is_expired(ctx->process_exp, now_ms))
Christopher Fauleta73e59b2016-12-09 17:30:18 +01003175 s->pending_events |= TASK_WOKEN_MSG;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003176}
3177
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003178/* Called when we are ready to filter data on a channel */
3179static int
3180spoe_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3181{
3182 struct spoe_context *ctx = filter->ctx;
3183 int ret = 1;
3184
3185 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3186 " - ctx-flags=0x%08x\n",
3187 (int)now.tv_sec, (int)now.tv_usec,
3188 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3189 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3190
Christopher Fauletb067b062017-01-04 16:39:11 +01003191 if (ctx->state == SPOE_CTX_ST_NONE)
3192 goto out;
3193
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003194 if (!(chn->flags & CF_ISRESP)) {
3195 if (filter->pre_analyzers & AN_REQ_INSPECT_FE)
3196 chn->analysers |= AN_REQ_INSPECT_FE;
3197 if (filter->pre_analyzers & AN_REQ_INSPECT_BE)
3198 chn->analysers |= AN_REQ_INSPECT_BE;
3199
3200 if (ctx->flags & SPOE_CTX_FL_CLI_CONNECTED)
3201 goto out;
3202
3203 ctx->stream_id = s->uniq_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01003204 ret = spoe_process_event(s, ctx, SPOE_EV_ON_CLIENT_SESS);
Christopher Fauletb067b062017-01-04 16:39:11 +01003205 if (!ret)
3206 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003207 ctx->flags |= SPOE_CTX_FL_CLI_CONNECTED;
3208 }
3209 else {
Miroslav Zagorac88403262020-06-19 22:17:17 +02003210 if (filter->pre_analyzers & AN_RES_INSPECT)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003211 chn->analysers |= AN_RES_INSPECT;
3212
3213 if (ctx->flags & SPOE_CTX_FL_SRV_CONNECTED)
3214 goto out;
3215
Christopher Faulet8ef75252017-02-20 22:56:03 +01003216 ret = spoe_process_event(s, ctx, SPOE_EV_ON_SERVER_SESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003217 if (!ret) {
3218 channel_dont_read(chn);
3219 channel_dont_close(chn);
Christopher Fauletb067b062017-01-04 16:39:11 +01003220 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003221 }
Christopher Fauletb067b062017-01-04 16:39:11 +01003222 ctx->flags |= SPOE_CTX_FL_SRV_CONNECTED;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003223 }
3224
3225 out:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003226 return ret;
3227}
3228
3229/* Called before a processing happens on a given channel */
3230static int
3231spoe_chn_pre_analyze(struct stream *s, struct filter *filter,
3232 struct channel *chn, unsigned an_bit)
3233{
3234 struct spoe_context *ctx = filter->ctx;
3235 int ret = 1;
3236
3237 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3238 " - ctx-flags=0x%08x - ana=0x%08x\n",
3239 (int)now.tv_sec, (int)now.tv_usec,
3240 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3241 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
3242 ctx->flags, an_bit);
3243
Christopher Fauletb067b062017-01-04 16:39:11 +01003244 if (ctx->state == SPOE_CTX_ST_NONE)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003245 goto out;
3246
3247 switch (an_bit) {
3248 case AN_REQ_INSPECT_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003249 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003250 break;
3251 case AN_REQ_INSPECT_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003252 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003253 break;
3254 case AN_RES_INSPECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003255 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003256 break;
3257 case AN_REQ_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003258 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003259 break;
3260 case AN_REQ_HTTP_PROCESS_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003261 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003262 break;
3263 case AN_RES_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003264 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003265 break;
3266 }
3267
3268 out:
Christopher Faulet9cdca972018-02-01 08:45:45 +01003269 if (!ret && (chn->flags & CF_ISRESP)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003270 channel_dont_read(chn);
3271 channel_dont_close(chn);
3272 }
3273 return ret;
3274}
3275
3276/* Called when the filtering on the channel ends. */
3277static int
3278spoe_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3279{
3280 struct spoe_context *ctx = filter->ctx;
3281
3282 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3283 " - ctx-flags=0x%08x\n",
3284 (int)now.tv_sec, (int)now.tv_usec,
3285 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3286 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3287
3288 if (!(ctx->flags & SPOE_CTX_FL_PROCESS)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003289 spoe_reset_context(ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003290 }
3291
3292 return 1;
3293}
3294
3295/********************************************************************
3296 * Functions that manage the filter initialization
3297 ********************************************************************/
3298struct flt_ops spoe_ops = {
3299 /* Manage SPOE filter, called for each filter declaration */
3300 .init = spoe_init,
3301 .deinit = spoe_deinit,
3302 .check = spoe_check,
Kevin Zhud87b1a52019-09-17 15:05:45 +02003303 .init_per_thread = spoe_init_per_thread,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003304
3305 /* Handle start/stop of SPOE */
Christopher Fauletf7a30922016-11-10 15:04:51 +01003306 .attach = spoe_start,
3307 .detach = spoe_stop,
3308 .check_timeouts = spoe_check_timeouts,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003309
3310 /* Handle channels activity */
3311 .channel_start_analyze = spoe_start_analyze,
3312 .channel_pre_analyze = spoe_chn_pre_analyze,
3313 .channel_end_analyze = spoe_end_analyze,
3314};
3315
3316
3317static int
3318cfg_parse_spoe_agent(const char *file, int linenum, char **args, int kwm)
3319{
3320 const char *err;
3321 int i, err_code = 0;
3322
3323 if ((cfg_scope == NULL && curengine != NULL) ||
3324 (cfg_scope != NULL && curengine == NULL) ||
Christopher Faulete1405e52017-09-19 10:35:35 +02003325 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003326 goto out;
3327
3328 if (!strcmp(args[0], "spoe-agent")) { /* new spoe-agent section */
3329 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003330 ha_alert("parsing [%s:%d] : missing name for spoe-agent section.\n",
3331 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003332 err_code |= ERR_ALERT | ERR_ABORT;
3333 goto out;
3334 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003335 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3336 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003337 goto out;
3338 }
3339
3340 err = invalid_char(args[1]);
3341 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003342 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3343 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003344 err_code |= ERR_ALERT | ERR_ABORT;
3345 goto out;
3346 }
3347
3348 if (curagent != NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003349 ha_alert("parsing [%s:%d] : another spoe-agent section previously defined.\n",
3350 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003351 err_code |= ERR_ALERT | ERR_ABORT;
3352 goto out;
3353 }
3354 if ((curagent = calloc(1, sizeof(*curagent))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003355 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003356 err_code |= ERR_ALERT | ERR_ABORT;
3357 goto out;
3358 }
3359
3360 curagent->id = strdup(args[1]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003361
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003362 curagent->conf.file = strdup(file);
3363 curagent->conf.line = linenum;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003364
3365 curagent->timeout.hello = TICK_ETERNITY;
3366 curagent->timeout.idle = TICK_ETERNITY;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003367 curagent->timeout.processing = TICK_ETERNITY;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003368
Christopher Fauleta1cda022016-12-21 08:58:06 +01003369 curagent->var_pfx = NULL;
3370 curagent->var_on_error = NULL;
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003371 curagent->var_t_process = NULL;
3372 curagent->var_t_total = NULL;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003373 curagent->flags = (SPOE_FL_ASYNC | SPOE_FL_PIPELINING | SPOE_FL_SND_FRAGMENTATION);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003374 curagent->cps_max = 0;
3375 curagent->eps_max = 0;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01003376 curagent->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01003377 curagent->max_fpa = 20;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003378
3379 for (i = 0; i < SPOE_EV_EVENTS; ++i)
Christopher Faulet11610f32017-09-21 10:23:10 +02003380 LIST_INIT(&curagent->events[i]);
3381 LIST_INIT(&curagent->groups);
3382 LIST_INIT(&curagent->messages);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003383 }
3384 else if (!strcmp(args[0], "use-backend")) {
3385 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003386 ha_alert("parsing [%s:%d] : '%s' expects a backend name.\n",
3387 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003388 err_code |= ERR_ALERT | ERR_FATAL;
3389 goto out;
3390 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003391 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003392 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003393 free(curagent->b.name);
3394 curagent->b.name = strdup(args[1]);
3395 }
3396 else if (!strcmp(args[0], "messages")) {
3397 int cur_arg = 1;
3398 while (*args[cur_arg]) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003399 struct spoe_placeholder *ph = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003400
Christopher Faulet11610f32017-09-21 10:23:10 +02003401 list_for_each_entry(ph, &curmphs, list) {
3402 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003403 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3404 file, linenum, args[cur_arg]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003405 err_code |= ERR_ALERT | ERR_FATAL;
3406 goto out;
3407 }
3408 }
3409
Christopher Faulet11610f32017-09-21 10:23:10 +02003410 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003411 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003412 err_code |= ERR_ALERT | ERR_ABORT;
3413 goto out;
3414 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003415 ph->id = strdup(args[cur_arg]);
3416 LIST_ADDQ(&curmphs, &ph->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003417 cur_arg++;
3418 }
3419 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003420 else if (!strcmp(args[0], "groups")) {
3421 int cur_arg = 1;
3422 while (*args[cur_arg]) {
3423 struct spoe_placeholder *ph = NULL;
3424
3425 list_for_each_entry(ph, &curgphs, list) {
3426 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003427 ha_alert("parsing [%s:%d]: spoe-group '%s' already used.\n",
3428 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003429 err_code |= ERR_ALERT | ERR_FATAL;
3430 goto out;
3431 }
3432 }
3433
3434 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003435 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003436 err_code |= ERR_ALERT | ERR_ABORT;
3437 goto out;
3438 }
3439 ph->id = strdup(args[cur_arg]);
3440 LIST_ADDQ(&curgphs, &ph->list);
3441 cur_arg++;
3442 }
3443 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003444 else if (!strcmp(args[0], "timeout")) {
3445 unsigned int *tv = NULL;
3446 const char *res;
3447 unsigned timeout;
3448
3449 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003450 ha_alert("parsing [%s:%d] : 'timeout' expects 'hello', 'idle' and 'processing'.\n",
3451 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003452 err_code |= ERR_ALERT | ERR_FATAL;
3453 goto out;
3454 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003455 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3456 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003457 if (!strcmp(args[1], "hello"))
3458 tv = &curagent->timeout.hello;
3459 else if (!strcmp(args[1], "idle"))
3460 tv = &curagent->timeout.idle;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003461 else if (!strcmp(args[1], "processing"))
3462 tv = &curagent->timeout.processing;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003463 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003464 ha_alert("parsing [%s:%d] : 'timeout' supports 'hello', 'idle' or 'processing' (got %s).\n",
3465 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003466 err_code |= ERR_ALERT | ERR_FATAL;
3467 goto out;
3468 }
3469 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003470 ha_alert("parsing [%s:%d] : 'timeout %s' expects an integer value (in milliseconds).\n",
3471 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003472 err_code |= ERR_ALERT | ERR_FATAL;
3473 goto out;
3474 }
3475 res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02003476 if (res == PARSE_TIME_OVER) {
3477 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
3478 file, linenum, args[2], args[0], args[1]);
3479 err_code |= ERR_ALERT | ERR_FATAL;
3480 goto out;
3481 }
3482 else if (res == PARSE_TIME_UNDER) {
3483 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
3484 file, linenum, args[2], args[0], args[1]);
3485 err_code |= ERR_ALERT | ERR_FATAL;
3486 goto out;
3487 }
3488 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003489 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'timeout %s'.\n",
3490 file, linenum, *res, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003491 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003492 goto out;
3493 }
3494 *tv = MS_TO_TICKS(timeout);
3495 }
3496 else if (!strcmp(args[0], "option")) {
3497 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003498 ha_alert("parsing [%s:%d]: '%s' expects an option name.\n",
3499 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003500 err_code |= ERR_ALERT | ERR_FATAL;
3501 goto out;
3502 }
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003503
Christopher Faulet305c6072017-02-23 16:17:53 +01003504 if (!strcmp(args[1], "pipelining")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003505 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003506 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003507 if (kwm == 1)
3508 curagent->flags &= ~SPOE_FL_PIPELINING;
3509 else
3510 curagent->flags |= SPOE_FL_PIPELINING;
3511 goto out;
3512 }
3513 else if (!strcmp(args[1], "async")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003514 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003515 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003516 if (kwm == 1)
3517 curagent->flags &= ~SPOE_FL_ASYNC;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003518 else
3519 curagent->flags |= SPOE_FL_ASYNC;
Christopher Faulet305c6072017-02-23 16:17:53 +01003520 goto out;
3521 }
Christopher Fauletcecd8522017-02-24 22:11:21 +01003522 else if (!strcmp(args[1], "send-frag-payload")) {
3523 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3524 goto out;
3525 if (kwm == 1)
3526 curagent->flags &= ~SPOE_FL_SND_FRAGMENTATION;
3527 else
3528 curagent->flags |= SPOE_FL_SND_FRAGMENTATION;
3529 goto out;
3530 }
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003531 else if (!strcmp(args[1], "dontlog-normal")) {
3532 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3533 goto out;
3534 if (kwm == 1)
3535 curpxopts2 &= ~PR_O2_NOLOGNORM;
3536 else
3537 curpxopts2 |= PR_O2_NOLOGNORM;
Christopher Faulet799f5182018-04-26 11:36:34 +02003538 goto out;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003539 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003540
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003541 /* Following options does not support negation */
3542 if (kwm == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003543 ha_alert("parsing [%s:%d]: negation is not supported for option '%s'.\n",
3544 file, linenum, args[1]);
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003545 err_code |= ERR_ALERT | ERR_FATAL;
3546 goto out;
3547 }
3548
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003549 if (!strcmp(args[1], "var-prefix")) {
3550 char *tmp;
3551
3552 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003553 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3554 file, linenum, args[0],
3555 args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003556 err_code |= ERR_ALERT | ERR_FATAL;
3557 goto out;
3558 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003559 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3560 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003561 tmp = args[2];
3562 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003563 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003564 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003565 file, linenum, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003566 err_code |= ERR_ALERT | ERR_FATAL;
3567 goto out;
3568 }
3569 tmp++;
3570 }
3571 curagent->var_pfx = strdup(args[2]);
3572 }
Etienne Carriereaec89892017-12-14 09:36:40 +00003573 else if (!strcmp(args[1], "force-set-var")) {
3574 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3575 goto out;
3576 curagent->flags |= SPOE_FL_FORCE_SET_VAR;
3577 }
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003578 else if (!strcmp(args[1], "continue-on-error")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003579 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003580 goto out;
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003581 curagent->flags |= SPOE_FL_CONT_ON_ERR;
3582 }
Christopher Faulet985532d2016-11-16 15:36:19 +01003583 else if (!strcmp(args[1], "set-on-error")) {
3584 char *tmp;
3585
3586 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003587 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3588 file, linenum, args[0],
3589 args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003590 err_code |= ERR_ALERT | ERR_FATAL;
3591 goto out;
3592 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003593 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3594 goto out;
Christopher Faulet985532d2016-11-16 15:36:19 +01003595 tmp = args[2];
3596 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003597 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003598 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003599 file, linenum, args[0], args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003600 err_code |= ERR_ALERT | ERR_FATAL;
3601 goto out;
3602 }
3603 tmp++;
3604 }
3605 curagent->var_on_error = strdup(args[2]);
3606 }
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003607 else if (!strcmp(args[1], "set-process-time")) {
3608 char *tmp;
3609
3610 if (!*args[2]) {
3611 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3612 file, linenum, args[0],
3613 args[1]);
3614 err_code |= ERR_ALERT | ERR_FATAL;
3615 goto out;
3616 }
3617 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3618 goto out;
3619 tmp = args[2];
3620 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003621 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003622 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003623 file, linenum, args[0], args[1]);
3624 err_code |= ERR_ALERT | ERR_FATAL;
3625 goto out;
3626 }
3627 tmp++;
3628 }
3629 curagent->var_t_process = strdup(args[2]);
3630 }
3631 else if (!strcmp(args[1], "set-total-time")) {
3632 char *tmp;
3633
3634 if (!*args[2]) {
3635 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3636 file, linenum, args[0],
3637 args[1]);
3638 err_code |= ERR_ALERT | ERR_FATAL;
3639 goto out;
3640 }
3641 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3642 goto out;
3643 tmp = args[2];
3644 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003645 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003646 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003647 file, linenum, args[0], args[1]);
3648 err_code |= ERR_ALERT | ERR_FATAL;
3649 goto out;
3650 }
3651 tmp++;
3652 }
3653 curagent->var_t_total = strdup(args[2]);
3654 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003655 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003656 ha_alert("parsing [%s:%d]: option '%s' is not supported.\n",
3657 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003658 err_code |= ERR_ALERT | ERR_FATAL;
3659 goto out;
3660 }
Christopher Faulet48026722016-11-16 15:01:12 +01003661 }
3662 else if (!strcmp(args[0], "maxconnrate")) {
3663 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003664 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3665 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003666 err_code |= ERR_ALERT | ERR_FATAL;
3667 goto out;
3668 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003669 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003670 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003671 curagent->cps_max = atol(args[1]);
3672 }
3673 else if (!strcmp(args[0], "maxerrrate")) {
3674 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003675 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3676 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003677 err_code |= ERR_ALERT | ERR_FATAL;
3678 goto out;
3679 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003680 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003681 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003682 curagent->eps_max = atol(args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003683 }
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003684 else if (!strcmp(args[0], "max-frame-size")) {
3685 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003686 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3687 file, linenum, args[0]);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003688 err_code |= ERR_ALERT | ERR_FATAL;
3689 goto out;
3690 }
3691 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3692 goto out;
3693 curagent->max_frame_size = atol(args[1]);
3694 if (curagent->max_frame_size < MIN_FRAME_SIZE ||
3695 curagent->max_frame_size > MAX_FRAME_SIZE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003696 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument in the range [%d, %d].\n",
3697 file, linenum, args[0], MIN_FRAME_SIZE, MAX_FRAME_SIZE);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003698 err_code |= ERR_ALERT | ERR_FATAL;
3699 goto out;
3700 }
3701 }
Christopher Faulete8ade382018-01-25 15:32:22 +01003702 else if (!strcmp(args[0], "max-waiting-frames")) {
3703 if (!*args[1]) {
3704 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3705 file, linenum, args[0]);
3706 err_code |= ERR_ALERT | ERR_FATAL;
3707 goto out;
3708 }
3709 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3710 goto out;
3711 curagent->max_fpa = atol(args[1]);
3712 if (curagent->max_fpa < 1) {
3713 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument.\n",
3714 file, linenum, args[0]);
3715 err_code |= ERR_ALERT | ERR_FATAL;
3716 goto out;
3717 }
3718 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003719 else if (!strcmp(args[0], "register-var-names")) {
3720 int cur_arg;
3721
3722 if (!*args[1]) {
3723 ha_alert("parsing [%s:%d] : '%s' expects one or more variable names.\n",
3724 file, linenum, args[0]);
3725 err_code |= ERR_ALERT | ERR_FATAL;
3726 goto out;
3727 }
3728 cur_arg = 1;
3729 while (*args[cur_arg]) {
3730 struct spoe_var_placeholder *vph;
3731
3732 if ((vph = calloc(1, sizeof(*vph))) == NULL) {
3733 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3734 err_code |= ERR_ALERT | ERR_ABORT;
3735 goto out;
3736 }
3737 if ((vph->name = strdup(args[cur_arg])) == NULL) {
Tim Duesterhusb2986132019-06-23 22:10:13 +02003738 free(vph);
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003739 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3740 err_code |= ERR_ALERT | ERR_ABORT;
3741 goto out;
3742 }
3743 LIST_ADDQ(&curvars, &vph->list);
3744 cur_arg++;
3745 }
3746 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003747 else if (!strcmp(args[0], "log")) {
3748 char *errmsg = NULL;
3749
3750 if (!parse_logsrv(args, &curlogsrvs, (kwm == 1), &errmsg)) {
3751 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
3752 err_code |= ERR_ALERT | ERR_FATAL;
3753 goto out;
3754 }
3755 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003756 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003757 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-agent section.\n",
3758 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003759 err_code |= ERR_ALERT | ERR_FATAL;
3760 goto out;
3761 }
3762 out:
3763 return err_code;
3764}
Christopher Faulet11610f32017-09-21 10:23:10 +02003765static int
3766cfg_parse_spoe_group(const char *file, int linenum, char **args, int kwm)
3767{
3768 struct spoe_group *grp;
3769 const char *err;
3770 int err_code = 0;
3771
3772 if ((cfg_scope == NULL && curengine != NULL) ||
3773 (cfg_scope != NULL && curengine == NULL) ||
3774 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
3775 goto out;
3776
3777 if (!strcmp(args[0], "spoe-group")) { /* new spoe-group section */
3778 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003779 ha_alert("parsing [%s:%d] : missing name for spoe-group section.\n",
3780 file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003781 err_code |= ERR_ALERT | ERR_ABORT;
3782 goto out;
3783 }
3784 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3785 err_code |= ERR_ABORT;
3786 goto out;
3787 }
3788
3789 err = invalid_char(args[1]);
3790 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003791 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3792 file, linenum, *err, args[0], args[1]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003793 err_code |= ERR_ALERT | ERR_ABORT;
3794 goto out;
3795 }
3796
3797 list_for_each_entry(grp, &curgrps, list) {
3798 if (!strcmp(grp->id, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003799 ha_alert("parsing [%s:%d]: spoe-group section '%s' has the same"
3800 " name as another one declared at %s:%d.\n",
3801 file, linenum, args[1], grp->conf.file, grp->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02003802 err_code |= ERR_ALERT | ERR_FATAL;
3803 goto out;
3804 }
3805 }
3806
3807 if ((curgrp = calloc(1, sizeof(*curgrp))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003808 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003809 err_code |= ERR_ALERT | ERR_ABORT;
3810 goto out;
3811 }
3812
3813 curgrp->id = strdup(args[1]);
3814 curgrp->conf.file = strdup(file);
3815 curgrp->conf.line = linenum;
3816 LIST_INIT(&curgrp->phs);
3817 LIST_INIT(&curgrp->messages);
3818 LIST_ADDQ(&curgrps, &curgrp->list);
3819 }
3820 else if (!strcmp(args[0], "messages")) {
3821 int cur_arg = 1;
3822 while (*args[cur_arg]) {
3823 struct spoe_placeholder *ph = NULL;
3824
3825 list_for_each_entry(ph, &curgrp->phs, list) {
3826 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003827 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3828 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003829 err_code |= ERR_ALERT | ERR_FATAL;
3830 goto out;
3831 }
3832 }
3833
3834 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003835 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003836 err_code |= ERR_ALERT | ERR_ABORT;
3837 goto out;
3838 }
3839 ph->id = strdup(args[cur_arg]);
3840 LIST_ADDQ(&curgrp->phs, &ph->list);
3841 cur_arg++;
3842 }
3843 }
3844 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003845 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-group section.\n",
3846 file, linenum, args[0]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003847 err_code |= ERR_ALERT | ERR_FATAL;
3848 goto out;
3849 }
3850 out:
3851 return err_code;
3852}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003853
3854static int
3855cfg_parse_spoe_message(const char *file, int linenum, char **args, int kwm)
3856{
3857 struct spoe_message *msg;
3858 struct spoe_arg *arg;
3859 const char *err;
3860 char *errmsg = NULL;
3861 int err_code = 0;
3862
3863 if ((cfg_scope == NULL && curengine != NULL) ||
3864 (cfg_scope != NULL && curengine == NULL) ||
Christopher Faulete1405e52017-09-19 10:35:35 +02003865 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003866 goto out;
3867
3868 if (!strcmp(args[0], "spoe-message")) { /* new spoe-message section */
3869 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003870 ha_alert("parsing [%s:%d] : missing name for spoe-message section.\n",
3871 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003872 err_code |= ERR_ALERT | ERR_ABORT;
3873 goto out;
3874 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003875 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3876 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003877 goto out;
3878 }
3879
3880 err = invalid_char(args[1]);
3881 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003882 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3883 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003884 err_code |= ERR_ALERT | ERR_ABORT;
3885 goto out;
3886 }
3887
3888 list_for_each_entry(msg, &curmsgs, list) {
3889 if (!strcmp(msg->id, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003890 ha_alert("parsing [%s:%d]: spoe-message section '%s' has the same"
3891 " name as another one declared at %s:%d.\n",
3892 file, linenum, args[1], msg->conf.file, msg->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003893 err_code |= ERR_ALERT | ERR_FATAL;
3894 goto out;
3895 }
3896 }
3897
3898 if ((curmsg = calloc(1, sizeof(*curmsg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003899 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003900 err_code |= ERR_ALERT | ERR_ABORT;
3901 goto out;
3902 }
3903
3904 curmsg->id = strdup(args[1]);
3905 curmsg->id_len = strlen(curmsg->id);
3906 curmsg->event = SPOE_EV_NONE;
3907 curmsg->conf.file = strdup(file);
3908 curmsg->conf.line = linenum;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003909 curmsg->nargs = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003910 LIST_INIT(&curmsg->args);
Christopher Faulet57583e42017-09-04 15:41:09 +02003911 LIST_INIT(&curmsg->acls);
Christopher Faulet11610f32017-09-21 10:23:10 +02003912 LIST_INIT(&curmsg->by_evt);
3913 LIST_INIT(&curmsg->by_grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003914 LIST_ADDQ(&curmsgs, &curmsg->list);
3915 }
3916 else if (!strcmp(args[0], "args")) {
3917 int cur_arg = 1;
3918
3919 curproxy->conf.args.ctx = ARGC_SPOE;
3920 curproxy->conf.args.file = file;
3921 curproxy->conf.args.line = linenum;
3922 while (*args[cur_arg]) {
3923 char *delim = strchr(args[cur_arg], '=');
3924 int idx = 0;
3925
3926 if ((arg = calloc(1, sizeof(*arg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003927 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003928 err_code |= ERR_ALERT | ERR_ABORT;
3929 goto out;
3930 }
3931
3932 if (!delim) {
3933 arg->name = NULL;
3934 arg->name_len = 0;
3935 delim = args[cur_arg];
3936 }
3937 else {
3938 arg->name = my_strndup(args[cur_arg], delim - args[cur_arg]);
3939 arg->name_len = delim - args[cur_arg];
3940 delim++;
3941 }
Christopher Fauletb0b42382017-02-23 22:41:09 +01003942 arg->expr = sample_parse_expr((char*[]){delim, NULL},
3943 &idx, file, linenum, &errmsg,
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01003944 &curproxy->conf.args, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003945 if (arg->expr == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003946 ha_alert("parsing [%s:%d] : '%s': %s.\n", file, linenum, args[0], errmsg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003947 err_code |= ERR_ALERT | ERR_FATAL;
3948 free(arg->name);
3949 free(arg);
3950 goto out;
3951 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003952 curmsg->nargs++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003953 LIST_ADDQ(&curmsg->args, &arg->list);
3954 cur_arg++;
3955 }
3956 curproxy->conf.args.file = NULL;
3957 curproxy->conf.args.line = 0;
3958 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003959 else if (!strcmp(args[0], "acl")) {
3960 err = invalid_char(args[1]);
3961 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003962 ha_alert("parsing [%s:%d] : character '%c' is not permitted in acl name '%s'.\n",
3963 file, linenum, *err, args[1]);
Christopher Faulet57583e42017-09-04 15:41:09 +02003964 err_code |= ERR_ALERT | ERR_FATAL;
3965 goto out;
3966 }
Tim Duesterhus0cf811a2020-02-05 21:00:50 +01003967 if (strcasecmp(args[1], "or") == 0) {
Tim Duesterhusf1bc24c2020-02-06 22:04:03 +01003968 ha_alert("parsing [%s:%d] : acl name '%s' will never match. 'or' is used to express a "
Tim Duesterhus0cf811a2020-02-05 21:00:50 +01003969 "logical disjunction within a condition.\n",
3970 file, linenum, args[1]);
3971 err_code |= ERR_ALERT | ERR_FATAL;
3972 goto out;
3973 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003974 if (parse_acl((const char **)args + 1, &curmsg->acls, &errmsg, &curproxy->conf.args, file, linenum) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003975 ha_alert("parsing [%s:%d] : error detected while parsing ACL '%s' : %s.\n",
3976 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02003977 err_code |= ERR_ALERT | ERR_FATAL;
3978 goto out;
3979 }
3980 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003981 else if (!strcmp(args[0], "event")) {
3982 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003983 ha_alert("parsing [%s:%d] : missing event name.\n", file, linenum);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003984 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003985 goto out;
3986 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003987 /* if (alertif_too_many_args(1, file, linenum, args, &err_code)) */
3988 /* goto out; */
Christopher Fauletecc537a2017-02-23 22:52:39 +01003989
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003990 if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_CLIENT_SESS]))
3991 curmsg->event = SPOE_EV_ON_CLIENT_SESS;
3992 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_SERVER_SESS]))
3993 curmsg->event = SPOE_EV_ON_SERVER_SESS;
3994
3995 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_FE]))
3996 curmsg->event = SPOE_EV_ON_TCP_REQ_FE;
3997 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_BE]))
3998 curmsg->event = SPOE_EV_ON_TCP_REQ_BE;
3999 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_RSP]))
4000 curmsg->event = SPOE_EV_ON_TCP_RSP;
4001
4002 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_FE]))
4003 curmsg->event = SPOE_EV_ON_HTTP_REQ_FE;
4004 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_BE]))
4005 curmsg->event = SPOE_EV_ON_HTTP_REQ_BE;
4006 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_RSP]))
4007 curmsg->event = SPOE_EV_ON_HTTP_RSP;
4008 else {
Joseph Herlantf1da69d2018-11-15 13:49:02 -08004009 ha_alert("parsing [%s:%d] : unknown event '%s'.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01004010 file, linenum, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01004011 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004012 goto out;
4013 }
Christopher Faulet57583e42017-09-04 15:41:09 +02004014
4015 if (strcmp(args[2], "if") == 0 || strcmp(args[2], "unless") == 0) {
4016 struct acl_cond *cond;
4017
4018 cond = build_acl_cond(file, linenum, &curmsg->acls,
4019 curproxy, (const char **)args+2,
4020 &errmsg);
4021 if (cond == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004022 ha_alert("parsing [%s:%d] : error detected while "
4023 "parsing an 'event %s' condition : %s.\n",
4024 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02004025 err_code |= ERR_ALERT | ERR_FATAL;
4026 goto out;
4027 }
4028 curmsg->cond = cond;
4029 }
4030 else if (*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004031 ha_alert("parsing [%s:%d]: 'event %s' expects either 'if' "
4032 "or 'unless' followed by a condition but found '%s'.\n",
4033 file, linenum, args[1], args[2]);
Christopher Faulet57583e42017-09-04 15:41:09 +02004034 err_code |= ERR_ALERT | ERR_FATAL;
4035 goto out;
4036 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004037 }
4038 else if (!*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004039 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-message section.\n",
4040 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004041 err_code |= ERR_ALERT | ERR_FATAL;
4042 goto out;
4043 }
4044 out:
4045 free(errmsg);
4046 return err_code;
4047}
4048
4049/* Return -1 on error, else 0 */
4050static int
4051parse_spoe_flt(char **args, int *cur_arg, struct proxy *px,
4052 struct flt_conf *fconf, char **err, void *private)
4053{
4054 struct list backup_sections;
4055 struct spoe_config *conf;
4056 struct spoe_message *msg, *msgback;
Christopher Faulet11610f32017-09-21 10:23:10 +02004057 struct spoe_group *grp, *grpback;
4058 struct spoe_placeholder *ph, *phback;
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004059 struct spoe_var_placeholder *vph, *vphback;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004060 struct logsrv *logsrv, *logsrvback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004061 char *file = NULL, *engine = NULL;
4062 int ret, pos = *cur_arg + 1;
4063
Christopher Faulet84c844e2018-03-23 14:37:14 +01004064 LIST_INIT(&curmsgs);
4065 LIST_INIT(&curgrps);
4066 LIST_INIT(&curmphs);
4067 LIST_INIT(&curgphs);
4068 LIST_INIT(&curvars);
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004069 LIST_INIT(&curlogsrvs);
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004070 curpxopts = 0;
4071 curpxopts2 = 0;
Christopher Faulet84c844e2018-03-23 14:37:14 +01004072
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004073 conf = calloc(1, sizeof(*conf));
4074 if (conf == NULL) {
4075 memprintf(err, "%s: out of memory", args[*cur_arg]);
4076 goto error;
4077 }
4078 conf->proxy = px;
4079
4080 while (*args[pos]) {
4081 if (!strcmp(args[pos], "config")) {
4082 if (!*args[pos+1]) {
4083 memprintf(err, "'%s' : '%s' option without value",
4084 args[*cur_arg], args[pos]);
4085 goto error;
4086 }
4087 file = args[pos+1];
4088 pos += 2;
4089 }
4090 else if (!strcmp(args[pos], "engine")) {
4091 if (!*args[pos+1]) {
4092 memprintf(err, "'%s' : '%s' option without value",
4093 args[*cur_arg], args[pos]);
4094 goto error;
4095 }
4096 engine = args[pos+1];
4097 pos += 2;
4098 }
4099 else {
4100 memprintf(err, "unknown keyword '%s'", args[pos]);
4101 goto error;
4102 }
4103 }
4104 if (file == NULL) {
4105 memprintf(err, "'%s' : missing config file", args[*cur_arg]);
4106 goto error;
4107 }
4108
4109 /* backup sections and register SPOE sections */
4110 LIST_INIT(&backup_sections);
4111 cfg_backup_sections(&backup_sections);
Christopher Faulet11610f32017-09-21 10:23:10 +02004112 cfg_register_section("spoe-agent", cfg_parse_spoe_agent, NULL);
4113 cfg_register_section("spoe-group", cfg_parse_spoe_group, NULL);
William Lallemandd2ff56d2017-10-16 11:06:50 +02004114 cfg_register_section("spoe-message", cfg_parse_spoe_message, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004115
4116 /* Parse SPOE filter configuration file */
4117 curengine = engine;
4118 curproxy = px;
4119 curagent = NULL;
4120 curmsg = NULL;
4121 ret = readcfgfile(file);
4122 curproxy = NULL;
4123
4124 /* unregister SPOE sections and restore previous sections */
4125 cfg_unregister_sections();
4126 cfg_restore_sections(&backup_sections);
4127
4128 if (ret == -1) {
4129 memprintf(err, "Could not open configuration file %s : %s",
4130 file, strerror(errno));
4131 goto error;
4132 }
4133 if (ret & (ERR_ABORT|ERR_FATAL)) {
4134 memprintf(err, "Error(s) found in configuration file %s", file);
4135 goto error;
4136 }
4137
4138 /* Check SPOE agent */
4139 if (curagent == NULL) {
4140 memprintf(err, "No SPOE agent found in file %s", file);
4141 goto error;
4142 }
4143 if (curagent->b.name == NULL) {
4144 memprintf(err, "No backend declared for SPOE agent '%s' declared at %s:%d",
4145 curagent->id, curagent->conf.file, curagent->conf.line);
4146 goto error;
4147 }
Christopher Fauletf7a30922016-11-10 15:04:51 +01004148 if (curagent->timeout.hello == TICK_ETERNITY ||
4149 curagent->timeout.idle == TICK_ETERNITY ||
Christopher Fauletf7a30922016-11-10 15:04:51 +01004150 curagent->timeout.processing == TICK_ETERNITY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004151 ha_warning("Proxy '%s': missing timeouts for SPOE agent '%s' declare at %s:%d.\n"
4152 " | While not properly invalid, you will certainly encounter various problems\n"
4153 " | with such a configuration. To fix this, please ensure that all following\n"
4154 " | timeouts are set to a non-zero value: 'hello', 'idle', 'processing'.\n",
4155 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004156 }
4157 if (curagent->var_pfx == NULL) {
4158 char *tmp = curagent->id;
4159
4160 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01004161 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004162 memprintf(err, "Invalid variable prefix '%s' for SPOE agent '%s' declared at %s:%d. "
4163 "Use 'option var-prefix' to set it. Only [a-zA-Z0-9_.] chars are supported.\n",
4164 curagent->id, curagent->id, curagent->conf.file, curagent->conf.line);
4165 goto error;
4166 }
4167 tmp++;
4168 }
4169 curagent->var_pfx = strdup(curagent->id);
4170 }
4171
Christopher Fauletb7426d12018-03-21 14:12:17 +01004172 if (curagent->var_on_error) {
4173 struct arg arg;
4174
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004175 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Fauletb7426d12018-03-21 14:12:17 +01004176 curagent->var_pfx, curagent->var_on_error);
4177
4178 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004179 arg.data.str.area = trash.area;
4180 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004181 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Fauletb7426d12018-03-21 14:12:17 +01004182 if (!vars_check_arg(&arg, err)) {
4183 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4184 curagent->id, curagent->var_pfx, curagent->var_on_error, *err);
4185 goto error;
4186 }
4187 }
4188
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004189 if (curagent->var_t_process) {
4190 struct arg arg;
4191
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004192 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004193 curagent->var_pfx, curagent->var_t_process);
4194
4195 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004196 arg.data.str.area = trash.area;
4197 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004198 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004199 if (!vars_check_arg(&arg, err)) {
4200 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4201 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4202 goto error;
4203 }
4204 }
4205
4206 if (curagent->var_t_total) {
4207 struct arg arg;
4208
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004209 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004210 curagent->var_pfx, curagent->var_t_total);
4211
4212 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004213 arg.data.str.area = trash.area;
4214 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004215 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004216 if (!vars_check_arg(&arg, err)) {
4217 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4218 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4219 goto error;
4220 }
4221 }
4222
Christopher Faulet11610f32017-09-21 10:23:10 +02004223 if (LIST_ISEMPTY(&curmphs) && LIST_ISEMPTY(&curgphs)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004224 ha_warning("Proxy '%s': No message/group used by SPOE agent '%s' declared at %s:%d.\n",
4225 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004226 goto finish;
4227 }
4228
Christopher Faulet11610f32017-09-21 10:23:10 +02004229 /* Replace placeholders by the corresponding messages for the SPOE
4230 * agent */
4231 list_for_each_entry(ph, &curmphs, list) {
4232 list_for_each_entry(msg, &curmsgs, list) {
Christopher Fauleta21b0642017-01-09 16:56:23 +01004233 struct spoe_arg *arg;
4234 unsigned int where;
4235
Christopher Faulet11610f32017-09-21 10:23:10 +02004236 if (!strcmp(msg->id, ph->id)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004237 if ((px->cap & (PR_CAP_FE|PR_CAP_BE)) == (PR_CAP_FE|PR_CAP_BE)) {
4238 if (msg->event == SPOE_EV_ON_TCP_REQ_BE)
4239 msg->event = SPOE_EV_ON_TCP_REQ_FE;
4240 if (msg->event == SPOE_EV_ON_HTTP_REQ_BE)
4241 msg->event = SPOE_EV_ON_HTTP_REQ_FE;
4242 }
4243 if (!(px->cap & PR_CAP_FE) && (msg->event == SPOE_EV_ON_CLIENT_SESS ||
4244 msg->event == SPOE_EV_ON_TCP_REQ_FE ||
4245 msg->event == SPOE_EV_ON_HTTP_REQ_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004246 ha_warning("Proxy '%s': frontend event used on a backend proxy at %s:%d.\n",
4247 px->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004248 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004249 }
4250 if (msg->event == SPOE_EV_NONE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004251 ha_warning("Proxy '%s': Ignore SPOE message '%s' without event at %s:%d.\n",
4252 px->id, msg->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004253 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004254 }
Christopher Fauleta21b0642017-01-09 16:56:23 +01004255
4256 where = 0;
4257 switch (msg->event) {
4258 case SPOE_EV_ON_CLIENT_SESS:
4259 where |= SMP_VAL_FE_CON_ACC;
4260 break;
4261
4262 case SPOE_EV_ON_TCP_REQ_FE:
4263 where |= SMP_VAL_FE_REQ_CNT;
4264 break;
4265
4266 case SPOE_EV_ON_HTTP_REQ_FE:
4267 where |= SMP_VAL_FE_HRQ_HDR;
4268 break;
4269
4270 case SPOE_EV_ON_TCP_REQ_BE:
4271 if (px->cap & PR_CAP_FE)
4272 where |= SMP_VAL_FE_REQ_CNT;
4273 if (px->cap & PR_CAP_BE)
4274 where |= SMP_VAL_BE_REQ_CNT;
4275 break;
4276
4277 case SPOE_EV_ON_HTTP_REQ_BE:
4278 if (px->cap & PR_CAP_FE)
4279 where |= SMP_VAL_FE_HRQ_HDR;
4280 if (px->cap & PR_CAP_BE)
4281 where |= SMP_VAL_BE_HRQ_HDR;
4282 break;
4283
4284 case SPOE_EV_ON_SERVER_SESS:
4285 where |= SMP_VAL_BE_SRV_CON;
4286 break;
4287
4288 case SPOE_EV_ON_TCP_RSP:
4289 if (px->cap & PR_CAP_FE)
4290 where |= SMP_VAL_FE_RES_CNT;
4291 if (px->cap & PR_CAP_BE)
4292 where |= SMP_VAL_BE_RES_CNT;
4293 break;
4294
4295 case SPOE_EV_ON_HTTP_RSP:
4296 if (px->cap & PR_CAP_FE)
4297 where |= SMP_VAL_FE_HRS_HDR;
4298 if (px->cap & PR_CAP_BE)
4299 where |= SMP_VAL_BE_HRS_HDR;
4300 break;
4301
4302 default:
4303 break;
4304 }
4305
4306 list_for_each_entry(arg, &msg->args, list) {
4307 if (!(arg->expr->fetch->val & where)) {
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004308 memprintf(err, "Ignore SPOE message '%s' at %s:%d: "
Christopher Fauleta21b0642017-01-09 16:56:23 +01004309 "some args extract information from '%s', "
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004310 "none of which is available here ('%s')",
4311 msg->id, msg->conf.file, msg->conf.line,
Christopher Fauleta21b0642017-01-09 16:56:23 +01004312 sample_ckp_names(arg->expr->fetch->use),
4313 sample_ckp_names(where));
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004314 goto error;
Christopher Fauleta21b0642017-01-09 16:56:23 +01004315 }
4316 }
4317
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004318 msg->agent = curagent;
Christopher Faulet11610f32017-09-21 10:23:10 +02004319 LIST_ADDQ(&curagent->events[msg->event], &msg->by_evt);
4320 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004321 }
4322 }
4323 memprintf(err, "SPOE agent '%s' try to use undefined SPOE message '%s' at %s:%d",
Christopher Faulet11610f32017-09-21 10:23:10 +02004324 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004325 goto error;
Christopher Faulet11610f32017-09-21 10:23:10 +02004326 next_mph:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004327 continue;
4328 }
4329
Christopher Faulet11610f32017-09-21 10:23:10 +02004330 /* Replace placeholders by the corresponding groups for the SPOE
4331 * agent */
4332 list_for_each_entry(ph, &curgphs, list) {
4333 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4334 if (!strcmp(grp->id, ph->id)) {
4335 grp->agent = curagent;
4336 LIST_DEL(&grp->list);
4337 LIST_ADDQ(&curagent->groups, &grp->list);
4338 goto next_aph;
4339 }
4340 }
4341 memprintf(err, "SPOE agent '%s' try to use undefined SPOE group '%s' at %s:%d",
4342 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
4343 goto error;
4344 next_aph:
4345 continue;
4346 }
4347
4348 /* Replace placeholders by the corresponding message for each SPOE
4349 * group of the SPOE agent */
4350 list_for_each_entry(grp, &curagent->groups, list) {
4351 list_for_each_entry_safe(ph, phback, &grp->phs, list) {
4352 list_for_each_entry(msg, &curmsgs, list) {
4353 if (!strcmp(msg->id, ph->id)) {
4354 if (msg->group != NULL) {
4355 memprintf(err, "SPOE message '%s' already belongs to "
4356 "the SPOE group '%s' declare at %s:%d",
4357 msg->id, msg->group->id,
4358 msg->group->conf.file,
4359 msg->group->conf.line);
4360 goto error;
4361 }
4362
4363 /* Scope for arguments are not checked for now. We will check
4364 * them only if a rule use the corresponding SPOE group. */
4365 msg->agent = curagent;
4366 msg->group = grp;
4367 LIST_DEL(&ph->list);
4368 LIST_ADDQ(&grp->messages, &msg->by_grp);
4369 goto next_mph_grp;
4370 }
4371 }
4372 memprintf(err, "SPOE group '%s' try to use undefined SPOE message '%s' at %s:%d",
4373 grp->id, ph->id, curagent->conf.file, curagent->conf.line);
4374 goto error;
4375 next_mph_grp:
4376 continue;
4377 }
4378 }
4379
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004380 finish:
Christopher Faulet11610f32017-09-21 10:23:10 +02004381 /* move curmsgs to the agent message list */
4382 curmsgs.n->p = &curagent->messages;
4383 curmsgs.p->n = &curagent->messages;
4384 curagent->messages = curmsgs;
4385 LIST_INIT(&curmsgs);
4386
Christopher Faulet7ee86672017-09-19 11:08:28 +02004387 conf->id = strdup(engine ? engine : curagent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004388 conf->agent = curagent;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004389
4390 /* Start agent's proxy initialization here. It will be finished during
4391 * the filter init. */
4392 memset(&conf->agent_fe, 0, sizeof(conf->agent_fe));
4393 init_new_proxy(&conf->agent_fe);
4394 conf->agent_fe.id = conf->agent->id;
4395 conf->agent_fe.parent = conf->agent;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004396 conf->agent_fe.options |= curpxopts;
4397 conf->agent_fe.options2 |= curpxopts2;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004398
4399 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4400 LIST_DEL(&logsrv->list);
4401 LIST_ADDQ(&conf->agent_fe.logsrvs, &logsrv->list);
4402 }
4403
Christopher Faulet11610f32017-09-21 10:23:10 +02004404 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4405 LIST_DEL(&ph->list);
4406 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004407 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004408 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4409 LIST_DEL(&ph->list);
4410 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004411 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004412 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4413 struct arg arg;
4414
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004415 trash.data = snprintf(trash.area, trash.size, "proc.%s.%s",
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004416 curagent->var_pfx, vph->name);
4417
4418 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004419 arg.data.str.area = trash.area;
4420 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004421 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004422 if (!vars_check_arg(&arg, err)) {
4423 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4424 curagent->id, curagent->var_pfx, vph->name, *err);
4425 goto error;
4426 }
4427
4428 LIST_DEL(&vph->list);
4429 free(vph->name);
4430 free(vph);
4431 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004432 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4433 LIST_DEL(&grp->list);
4434 spoe_release_group(grp);
4435 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004436 *cur_arg = pos;
Christopher Faulet3b386a32017-02-23 10:17:15 +01004437 fconf->id = spoe_filter_id;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004438 fconf->ops = &spoe_ops;
4439 fconf->conf = conf;
4440 return 0;
4441
4442 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01004443 spoe_release_agent(curagent);
Christopher Faulet11610f32017-09-21 10:23:10 +02004444 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4445 LIST_DEL(&ph->list);
4446 spoe_release_placeholder(ph);
4447 }
4448 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4449 LIST_DEL(&ph->list);
4450 spoe_release_placeholder(ph);
4451 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004452 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4453 LIST_DEL(&vph->list);
4454 free(vph->name);
4455 free(vph);
4456 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004457 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4458 LIST_DEL(&grp->list);
4459 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004460 }
4461 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
4462 LIST_DEL(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01004463 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004464 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004465 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4466 LIST_DEL(&logsrv->list);
4467 free(logsrv);
4468 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004469 free(conf);
4470 return -1;
4471}
4472
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004473/* Send message of a SPOE group. This is the action_ptr callback of a rule
4474 * associated to a "send-spoe-group" action.
4475 *
Christopher Faulet13403762019-12-13 09:01:57 +01004476 * It returns ACT_RET_CONT if processing is finished (with error or not), it returns
4477 * ACT_RET_YIELD if the action is in progress. */
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004478static enum act_return
4479spoe_send_group(struct act_rule *rule, struct proxy *px,
4480 struct session *sess, struct stream *s, int flags)
4481{
4482 struct filter *filter;
4483 struct spoe_agent *agent = NULL;
4484 struct spoe_group *group = NULL;
4485 struct spoe_context *ctx = NULL;
4486 int ret, dir;
4487
4488 list_for_each_entry(filter, &s->strm_flt.filters, list) {
4489 if (filter->config == rule->arg.act.p[0]) {
4490 agent = rule->arg.act.p[2];
4491 group = rule->arg.act.p[3];
4492 ctx = filter->ctx;
4493 break;
4494 }
4495 }
4496 if (agent == NULL || group == NULL || ctx == NULL)
Christopher Faulet13403762019-12-13 09:01:57 +01004497 return ACT_RET_CONT;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004498 if (ctx->state == SPOE_CTX_ST_NONE)
4499 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004500
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004501 switch (rule->from) {
4502 case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break;
4503 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
4504 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
4505 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
4506 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
4507 default:
4508 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4509 " - internal error while execute spoe-send-group\n",
4510 (int)now.tv_sec, (int)now.tv_usec, agent->id,
4511 __FUNCTION__, s);
4512 send_log(px, LOG_ERR, "SPOE: [%s] internal error while execute spoe-send-group\n",
4513 agent->id);
4514 return ACT_RET_CONT;
4515 }
4516
4517 ret = spoe_process_group(s, ctx, group, dir);
4518 if (ret == 1)
4519 return ACT_RET_CONT;
4520 else if (ret == 0) {
Christopher Faulet105ba6c2019-12-18 14:41:51 +01004521 if (flags & ACT_OPT_FINAL) {
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004522 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4523 " - failed to process group '%s': interrupted by caller\n",
4524 (int)now.tv_sec, (int)now.tv_usec,
4525 agent->id, __FUNCTION__, s, group->id);
4526 ctx->status_code = SPOE_CTX_ERR_INTERRUPT;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01004527 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02004528 spoe_handle_processing_error(s, agent, ctx, dir);
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004529 return ACT_RET_CONT;
4530 }
4531 return ACT_RET_YIELD;
4532 }
4533 else
Christopher Faulet13403762019-12-13 09:01:57 +01004534 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004535}
4536
4537/* Check an "send-spoe-group" action. Here, we'll try to find the real SPOE
4538 * group associated to <rule>. The format of an rule using 'send-spoe-group'
4539 * action should be:
4540 *
4541 * (http|tcp)-(request|response) send-spoe-group <engine-id> <group-id>
4542 *
4543 * So, we'll loop on each configured SPOE filter for the proxy <px> to find the
4544 * SPOE engine matching <engine-id>. And then, we'll try to find the good group
4545 * matching <group-id>. Finally, we'll check all messages referenced by the SPOE
4546 * group.
4547 *
4548 * The function returns 1 in success case, otherwise, it returns 0 and err is
4549 * filled.
4550 */
4551static int
4552check_send_spoe_group(struct act_rule *rule, struct proxy *px, char **err)
4553{
4554 struct flt_conf *fconf;
4555 struct spoe_config *conf;
4556 struct spoe_agent *agent = NULL;
4557 struct spoe_group *group;
4558 struct spoe_message *msg;
4559 char *engine_id = rule->arg.act.p[0];
4560 char *group_id = rule->arg.act.p[1];
4561 unsigned int where = 0;
4562
4563 switch (rule->from) {
4564 case ACT_F_TCP_REQ_SES: where = SMP_VAL_FE_SES_ACC; break;
4565 case ACT_F_TCP_REQ_CNT: where = SMP_VAL_FE_REQ_CNT; break;
4566 case ACT_F_TCP_RES_CNT: where = SMP_VAL_BE_RES_CNT; break;
4567 case ACT_F_HTTP_REQ: where = SMP_VAL_FE_HRQ_HDR; break;
4568 case ACT_F_HTTP_RES: where = SMP_VAL_BE_HRS_HDR; break;
4569 default:
4570 memprintf(err,
4571 "internal error, unexpected rule->from=%d, please report this bug!",
4572 rule->from);
4573 goto error;
4574 }
4575
4576 /* Try to find the SPOE engine by checking all SPOE filters for proxy
4577 * <px> */
4578 list_for_each_entry(fconf, &px->filter_configs, list) {
4579 conf = fconf->conf;
4580
4581 /* This is not an SPOE filter */
4582 if (fconf->id != spoe_filter_id)
4583 continue;
4584
4585 /* This is the good engine */
4586 if (!strcmp(conf->id, engine_id)) {
4587 agent = conf->agent;
4588 break;
4589 }
4590 }
4591 if (agent == NULL) {
4592 memprintf(err, "unable to find SPOE engine '%s' used by the send-spoe-group '%s'",
4593 engine_id, group_id);
4594 goto error;
4595 }
4596
4597 /* Try to find the right group */
4598 list_for_each_entry(group, &agent->groups, list) {
4599 /* This is the good group */
4600 if (!strcmp(group->id, group_id))
4601 break;
4602 }
4603 if (&group->list == &agent->groups) {
4604 memprintf(err, "unable to find SPOE group '%s' into SPOE engine '%s' configuration",
4605 group_id, engine_id);
4606 goto error;
4607 }
4608
4609 /* Ok, we found the group, we need to check messages and their
4610 * arguments */
4611 list_for_each_entry(msg, &group->messages, by_grp) {
4612 struct spoe_arg *arg;
4613
4614 list_for_each_entry(arg, &msg->args, list) {
4615 if (!(arg->expr->fetch->val & where)) {
4616 memprintf(err, "Invalid SPOE message '%s' used by SPOE group '%s' at %s:%d: "
4617 "some args extract information from '%s',"
4618 "none of which is available here ('%s')",
4619 msg->id, group->id, msg->conf.file, msg->conf.line,
4620 sample_ckp_names(arg->expr->fetch->use),
4621 sample_ckp_names(where));
4622 goto error;
4623 }
4624 }
4625 }
4626
4627 free(engine_id);
4628 free(group_id);
4629 rule->arg.act.p[0] = fconf; /* Associate filter config with the rule */
4630 rule->arg.act.p[1] = conf; /* Associate SPOE config with the rule */
4631 rule->arg.act.p[2] = agent; /* Associate SPOE agent with the rule */
4632 rule->arg.act.p[3] = group; /* Associate SPOE group with the rule */
4633 return 1;
4634
4635 error:
4636 free(engine_id);
4637 free(group_id);
4638 return 0;
4639}
4640
4641/* Parse 'send-spoe-group' action following the format:
4642 *
4643 * ... send-spoe-group <engine-id> <group-id>
4644 *
4645 * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error
4646 * message. Otherwise, it returns ACT_RET_PRS_OK and parsing engine and group
4647 * ids are saved and used later, when the rule will be checked.
4648 */
4649static enum act_parse_ret
4650parse_send_spoe_group(const char **args, int *orig_arg, struct proxy *px,
4651 struct act_rule *rule, char **err)
4652{
4653 if (!*args[*orig_arg] || !*args[*orig_arg+1] ||
4654 (*args[*orig_arg+2] && strcmp(args[*orig_arg+2], "if") != 0 && strcmp(args[*orig_arg+2], "unless") != 0)) {
4655 memprintf(err, "expects 2 arguments: <engine-id> <group-id>");
4656 return ACT_RET_PRS_ERR;
4657 }
4658 rule->arg.act.p[0] = strdup(args[*orig_arg]); /* Copy the SPOE engine id */
4659 rule->arg.act.p[1] = strdup(args[*orig_arg+1]); /* Cope the SPOE group id */
4660
4661 (*orig_arg) += 2;
4662
4663 rule->action = ACT_CUSTOM;
4664 rule->action_ptr = spoe_send_group;
4665 rule->check_ptr = check_send_spoe_group;
4666 return ACT_RET_PRS_OK;
4667}
4668
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004669
4670/* Declare the filter parser for "spoe" keyword */
4671static struct flt_kw_list flt_kws = { "SPOE", { }, {
4672 { "spoe", parse_spoe_flt, NULL },
4673 { NULL, NULL, NULL },
4674 }
4675};
4676
Willy Tarreau0108d902018-11-25 19:14:37 +01004677INITCALL1(STG_REGISTER, flt_register_keywords, &flt_kws);
4678
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004679/* Delcate the action parser for "spoe-action" keyword */
4680static struct action_kw_list tcp_req_action_kws = { { }, {
4681 { "send-spoe-group", parse_send_spoe_group },
4682 { /* END */ },
4683 }
4684};
Willy Tarreau0108d902018-11-25 19:14:37 +01004685
4686INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_action_kws);
4687
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004688static struct action_kw_list tcp_res_action_kws = { { }, {
4689 { "send-spoe-group", parse_send_spoe_group },
4690 { /* END */ },
4691 }
4692};
Willy Tarreau0108d902018-11-25 19:14:37 +01004693
4694INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_action_kws);
4695
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004696static struct action_kw_list http_req_action_kws = { { }, {
4697 { "send-spoe-group", parse_send_spoe_group },
4698 { /* END */ },
4699 }
4700};
Willy Tarreau0108d902018-11-25 19:14:37 +01004701
4702INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_action_kws);
4703
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004704static struct action_kw_list http_res_action_kws = { { }, {
4705 { "send-spoe-group", parse_send_spoe_group },
4706 { /* END */ },
4707 }
4708};
4709
Willy Tarreau0108d902018-11-25 19:14:37 +01004710INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_action_kws);