blob: 62e535ef118834a545e0795841b8b1b29b26abcf [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 Faulet3a47e5e2018-05-25 10:42:37 +02001012 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1013 return -1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001014 return 0;
1015
1016 found:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001017 if (!spoe_acquire_buffer(&SPOE_APPCTX(appctx)->buffer,
1018 &SPOE_APPCTX(appctx)->buffer_wait)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001019 *ctx = NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001020 return 1; /* Retry later */
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001021 }
Christopher Faulet4596fb72017-01-11 14:05:19 +01001022
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001023 /* Copy encoded actions */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001024 len = (end - p);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001025 memcpy(b_head(&SPOE_APPCTX(appctx)->buffer), p, len);
1026 b_set_data(&SPOE_APPCTX(appctx)->buffer, len);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001027 p += len;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001028
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001029 /* Transfer the buffer ownership to the SPOE context */
1030 (*ctx)->buffer = SPOE_APPCTX(appctx)->buffer;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001031 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001032
Christopher Faulet8ef75252017-02-20 22:56:03 +01001033 (*ctx)->state = SPOE_CTX_ST_DONE;
1034
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001035 end:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001036 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001037 " - ACK frame received"
1038 " - ctx=%p - stream-id=%u - frame-id=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001039 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001040 __FUNCTION__, appctx, *ctx, (*ctx)->stream_id,
1041 (*ctx)->frame_id, flags);
1042 return (p - frame);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001043}
1044
Christopher Fauletba7bc162016-11-07 21:07:38 +01001045/* This function is used in cfgparse.c and declared in proto/checks.h. It
1046 * prepare the request to send to agents during a healthcheck. It returns 0 on
1047 * success and -1 if an error occurred. */
1048int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001049spoe_prepare_healthcheck_request(char **req, int *len)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001050{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001051 struct appctx appctx;
1052 struct spoe_appctx spoe_appctx;
1053 char *frame, *end, buf[MAX_FRAME_SIZE+4];
1054 size_t sz;
1055 int ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001056
Christopher Faulet42bfa462017-01-04 14:14:19 +01001057 memset(&appctx, 0, sizeof(appctx));
1058 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001059 memset(buf, 0, sizeof(buf));
Christopher Faulet42bfa462017-01-04 14:14:19 +01001060
1061 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001062 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001063
Christopher Faulet8ef75252017-02-20 22:56:03 +01001064 frame = buf+4; /* Reserved the 4 first bytes for the frame size */
1065 end = frame + MAX_FRAME_SIZE;
1066
1067 ret = spoe_prepare_hahello_frame(&appctx, frame, MAX_FRAME_SIZE);
1068 if (ret <= 0)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001069 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001070 frame += ret;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001071
Christopher Faulet8ef75252017-02-20 22:56:03 +01001072 /* Add "healthcheck" K/V item */
1073 sz = SLEN(HEALTHCHECK_KEY);
1074 if (spoe_encode_buffer(HEALTHCHECK_KEY, sz, &frame, end) == -1)
1075 return -1;
1076 *frame++ = (SPOE_DATA_T_BOOL | SPOE_DATA_FL_TRUE);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001077
Christopher Faulet8ef75252017-02-20 22:56:03 +01001078 *len = frame - buf;
1079 sz = htonl(*len - 4);
1080 memcpy(buf, (char *)&sz, 4);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001081
Christopher Faulet8ef75252017-02-20 22:56:03 +01001082 if ((*req = malloc(*len)) == NULL)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001083 return -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001084 memcpy(*req, buf, *len);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001085 return 0;
1086}
1087
1088/* This function is used in checks.c and declared in proto/checks.h. It decode
1089 * the response received from an agent during a healthcheck. It returns 0 on
1090 * success and -1 if an error occurred. */
1091int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001092spoe_handle_healthcheck_response(char *frame, size_t size, char *err, int errlen)
Christopher Fauletba7bc162016-11-07 21:07:38 +01001093{
Christopher Faulet42bfa462017-01-04 14:14:19 +01001094 struct appctx appctx;
1095 struct spoe_appctx spoe_appctx;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001096
Christopher Faulet42bfa462017-01-04 14:14:19 +01001097 memset(&appctx, 0, sizeof(appctx));
1098 memset(&spoe_appctx, 0, sizeof(spoe_appctx));
Christopher Fauletba7bc162016-11-07 21:07:38 +01001099
Christopher Faulet42bfa462017-01-04 14:14:19 +01001100 appctx.ctx.spoe.ptr = &spoe_appctx;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001101 SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001102
Christopher Faulet8ef75252017-02-20 22:56:03 +01001103 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1104 spoe_handle_agentdiscon_frame(&appctx, frame, size);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001105 goto error;
1106 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001107 if (spoe_handle_agenthello_frame(&appctx, frame, size) <= 0)
1108 goto error;
Christopher Fauletba7bc162016-11-07 21:07:38 +01001109
1110 return 0;
1111
1112 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001113 if (SPOE_APPCTX(&appctx)->status_code >= SPOE_FRM_ERRS)
1114 SPOE_APPCTX(&appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
1115 strncpy(err, spoe_frm_err_reasons[SPOE_APPCTX(&appctx)->status_code], errlen);
Christopher Fauletba7bc162016-11-07 21:07:38 +01001116 return -1;
1117}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001118
Christopher Fauleta1cda022016-12-21 08:58:06 +01001119/* Send a SPOE frame to an agent. It returns -1 when an error occurred, 0 when
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05001120 * the frame can be ignored, 1 to retry later, and the frame length on
Christopher Fauleta1cda022016-12-21 08:58:06 +01001121 * success. */
1122static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001123spoe_send_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001124{
1125 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001126 int ret;
1127 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001128
Christopher Faulet8ef75252017-02-20 22:56:03 +01001129 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1130 * length. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001131 netint = htonl(framesz);
1132 memcpy(buf, (char *)&netint, 4);
Willy Tarreau06d80a92017-10-19 14:32:15 +02001133 ret = ci_putblk(si_ic(si), buf, framesz+4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001134 if (ret <= 0) {
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001135 if ((ret == -3 && b_is_null(&si_ic(si)->buf)) || ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001136 si_rx_room_blk(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001137 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001138 }
1139 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001140 return -1; /* error */
1141 }
1142 return framesz;
1143}
1144
1145/* Receive a SPOE frame from an agent. It return -1 when an error occurred, 0
1146 * when the frame can be ignored, 1 to retry later and the frame length on
1147 * success. */
1148static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001149spoe_recv_frame(struct appctx *appctx, char *buf, size_t framesz)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001150{
1151 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001152 int ret;
1153 uint32_t netint;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001154
Willy Tarreau06d80a92017-10-19 14:32:15 +02001155 ret = co_getblk(si_oc(si), (char *)&netint, 4, 0);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001156 if (ret > 0) {
1157 framesz = ntohl(netint);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001158 if (framesz > SPOE_APPCTX(appctx)->max_frame_size) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001159 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001160 return -1;
1161 }
Willy Tarreau06d80a92017-10-19 14:32:15 +02001162 ret = co_getblk(si_oc(si), buf, framesz, 4);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001163 }
1164 if (ret <= 0) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001165 if (ret == 0) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001166 return 1; /* retry */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001167 }
1168 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001169 return -1; /* error */
1170 }
1171 return framesz;
1172}
1173
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001174/********************************************************************
1175 * Functions that manage the SPOE applet
1176 ********************************************************************/
Christopher Faulet4596fb72017-01-11 14:05:19 +01001177static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001178spoe_wakeup_appctx(struct appctx *appctx)
Christopher Faulet4596fb72017-01-11 14:05:19 +01001179{
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001180 si_want_get(appctx->owner);
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001181 si_rx_endp_more(appctx->owner);
Christopher Faulet4596fb72017-01-11 14:05:19 +01001182 appctx_wakeup(appctx);
1183 return 1;
1184}
1185
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001186/* Callback function that catches applet timeouts. If a timeout occurred, we set
1187 * <appctx->st1> flag and the SPOE applet is woken up. */
1188static struct task *
Olivier Houchard9f6af332018-05-25 14:04:04 +02001189spoe_process_appctx(struct task * task, void *context, unsigned short state)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001190{
Olivier Houchard9f6af332018-05-25 14:04:04 +02001191 struct appctx *appctx = context;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001192
1193 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1194 if (tick_is_expired(task->expire, now_ms)) {
1195 task->expire = TICK_ETERNITY;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001196 appctx->st1 = SPOE_APPCTX_ERR_TOUT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001197 }
Christopher Faulet8ef75252017-02-20 22:56:03 +01001198 spoe_wakeup_appctx(appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001199 return task;
1200}
1201
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001202/* Callback function that releases a SPOE applet. This happens when the
1203 * connection with the agent is closed. */
1204static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001205spoe_release_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001206{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001207 struct stream_interface *si = appctx->owner;
1208 struct spoe_appctx *spoe_appctx = SPOE_APPCTX(appctx);
1209 struct spoe_agent *agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001210 struct spoe_context *ctx, *back;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001211
1212 if (spoe_appctx == NULL)
1213 return;
1214
1215 appctx->ctx.spoe.ptr = NULL;
1216 agent = spoe_appctx->agent;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001217
1218 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p\n",
1219 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1220 __FUNCTION__, appctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001221
Christopher Faulet8ef75252017-02-20 22:56:03 +01001222 /* Remove applet from the list of running applets */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001223 _HA_ATOMIC_SUB(&agent->counters.applets, 1);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001224 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001225 if (!LIST_ISEMPTY(&spoe_appctx->list)) {
1226 LIST_DEL(&spoe_appctx->list);
1227 LIST_INIT(&spoe_appctx->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001228 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001229 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001230
Christopher Faulet8ef75252017-02-20 22:56:03 +01001231 /* Shutdown the server connection, if needed */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001232 if (appctx->st0 != SPOE_APPCTX_ST_END) {
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001233 if (appctx->st0 == SPOE_APPCTX_ST_IDLE) {
1234 eb32_delete(&spoe_appctx->node);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001235 _HA_ATOMIC_SUB(&agent->counters.idles, 1);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001236 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001237
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001238 appctx->st0 = SPOE_APPCTX_ST_END;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001239 if (spoe_appctx->status_code == SPOE_FRM_ERR_NONE)
1240 spoe_appctx->status_code = SPOE_FRM_ERR_IO;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001241
1242 si_shutw(si);
1243 si_shutr(si);
1244 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001245 }
1246
Christopher Faulet8ef75252017-02-20 22:56:03 +01001247 /* Destroy the task attached to this applet */
Willy Tarreauf6562792019-05-07 19:05:35 +02001248 task_destroy(spoe_appctx->task);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001249
Christopher Faulet8ef75252017-02-20 22:56:03 +01001250 /* Notify all waiting streams */
1251 list_for_each_entry_safe(ctx, back, &spoe_appctx->waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001252 LIST_DEL(&ctx->list);
1253 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001254 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001255 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001256 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001257 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001258 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001259 }
1260
Christopher Faulet8ef75252017-02-20 22:56:03 +01001261 /* If the applet was processing a fragmented frame, notify the
1262 * corresponding stream. */
1263 if (spoe_appctx->frag_ctx.ctx) {
1264 ctx = spoe_appctx->frag_ctx.ctx;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001265 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001266 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001267 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001268 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1269 }
1270
Christopher Faulet24289f22017-09-25 14:48:02 +02001271 if (!LIST_ISEMPTY(&agent->rt[tid].applets))
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001272 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001273
Christopher Faulet8ef75252017-02-20 22:56:03 +01001274 /* If this was the last running applet, notify all waiting streams */
Christopher Faulet24289f22017-09-25 14:48:02 +02001275 list_for_each_entry_safe(ctx, back, &agent->rt[tid].sending_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001276 LIST_DEL(&ctx->list);
1277 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001278 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001279 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001280 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001281 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001282 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001283 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001284 list_for_each_entry_safe(ctx, back, &agent->rt[tid].waiting_queue, list) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01001285 LIST_DEL(&ctx->list);
1286 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001287 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001288 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001289 ctx->state = SPOE_CTX_ST_ERROR;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001290 ctx->status_code = (spoe_appctx->status_code + 0x100);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001291 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1292 }
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001293
1294 end:
Christopher Faulet55ae8a62019-05-23 22:47:48 +02001295 /* Release allocated memory */
1296 spoe_release_buffer(&spoe_appctx->buffer,
1297 &spoe_appctx->buffer_wait);
1298 pool_free(pool_head_spoe_appctx, spoe_appctx);
1299
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001300 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001301 agent->rt[tid].frame_size = agent->max_frame_size;
1302 list_for_each_entry(spoe_appctx, &agent->rt[tid].applets, list)
1303 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, spoe_appctx->max_frame_size);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001304}
1305
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001306static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001307spoe_handle_connect_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001308{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001309 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001310 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001311 char *frame, *buf;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001312 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001313
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001314 if (si_state_in(si->state, SI_SB_CER|SI_SB_DIS|SI_SB_CLO)) {
1315 /* closed */
1316 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1317 goto exit;
1318 }
1319
Willy Tarreau4f283fa2019-06-05 14:34:03 +02001320 if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST)) {
Willy Tarreau7ab22adb2019-06-05 14:53:22 +02001321 /* not connected yet */
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +01001322 si_rx_endp_more(si);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001323 task_wakeup(si_strm(si)->task, TASK_WOKEN_MSG);
1324 goto stop;
1325 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001326
Christopher Fauleta1cda022016-12-21 08:58:06 +01001327 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001328 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1329 " - Connection timed out\n",
1330 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1331 __FUNCTION__, appctx);
1332 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001333 goto exit;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001334 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001335
Christopher Faulet42bfa462017-01-04 14:14:19 +01001336 if (SPOE_APPCTX(appctx)->task->expire == TICK_ETERNITY)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001337 SPOE_APPCTX(appctx)->task->expire =
1338 tick_add_ifset(now_ms, agent->timeout.hello);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001339
Christopher Faulet8ef75252017-02-20 22:56:03 +01001340 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1341 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001342 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001343 ret = spoe_prepare_hahello_frame(appctx, frame,
1344 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001345 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001346 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001347
1348 switch (ret) {
1349 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001350 case 0: /* ignore => an error, cannot be ignored */
1351 goto exit;
1352
1353 case 1: /* retry later */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001354 goto stop;
1355
Christopher Faulet8ef75252017-02-20 22:56:03 +01001356 default:
1357 /* HELLO frame successfully sent, now wait for the
1358 * reply. */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001359 appctx->st0 = SPOE_APPCTX_ST_CONNECTING;
1360 goto next;
1361 }
1362
1363 next:
1364 return 0;
1365 stop:
1366 return 1;
1367 exit:
1368 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1369 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001370}
1371
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001372static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001373spoe_handle_connecting_appctx(struct appctx *appctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001374{
Christopher Fauleta1cda022016-12-21 08:58:06 +01001375 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001376 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001377 char *frame;
1378 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001379
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001380
Christopher Fauletb067b062017-01-04 16:39:11 +01001381 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001382 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001383 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001384 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001385
Christopher Fauleta1cda022016-12-21 08:58:06 +01001386 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001387 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1388 " - Connection timed out\n",
1389 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1390 __FUNCTION__, appctx);
1391 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001392 goto exit;
1393 }
1394
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001395 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001396 ret = spoe_recv_frame(appctx, frame,
1397 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001398 if (ret > 1) {
1399 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1400 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1401 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001402 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001403 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001404 ret = spoe_handle_agenthello_frame(appctx, frame, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001405 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001406
Christopher Fauleta1cda022016-12-21 08:58:06 +01001407 switch (ret) {
1408 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001409 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001410 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1411 goto next;
1412
1413 case 1: /* retry later */
1414 goto stop;
1415
1416 default:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001417 /* HELLO handshake is finished, set the idle timeout and
1418 * add the applet in the list of running applets. */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001419 _HA_ATOMIC_ADD(&agent->counters.idles, 1);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001420 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001421 SPOE_APPCTX(appctx)->node.key = 0;
1422 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01001423
1424 /* Update runtinme agent info */
Christopher Faulet24289f22017-09-25 14:48:02 +02001425 HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001426 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001427 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001428
Christopher Fauleta1cda022016-12-21 08:58:06 +01001429 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001430 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001431 if (trash.data)
1432 co_skip(si_oc(si), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001433
1434 SPOE_APPCTX(appctx)->task->expire =
1435 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001436 return 0;
1437 stop:
1438 return 1;
1439 exit:
1440 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1441 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001442}
1443
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001444
Christopher Fauleta1cda022016-12-21 08:58:06 +01001445static int
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001446spoe_handle_sending_frame_appctx(struct appctx *appctx, int *skip)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001447{
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001448 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
1449 struct spoe_context *ctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001450 char *frame, *buf;
1451 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001452
Christopher Faulet8ef75252017-02-20 22:56:03 +01001453 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1454 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001455 buf = trash.area; frame = buf+4;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001456
1457 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY) {
1458 ctx = SPOE_APPCTX(appctx)->frag_ctx.ctx;
1459 ret = spoe_prepare_hafrag_frame(appctx, ctx, frame,
1460 SPOE_APPCTX(appctx)->max_frame_size);
1461 }
Christopher Faulet24289f22017-09-25 14:48:02 +02001462 else if (LIST_ISEMPTY(&agent->rt[tid].sending_queue)) {
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001463 *skip = 1;
1464 ret = 1;
1465 goto end;
1466 }
1467 else {
Christopher Faulet24289f22017-09-25 14:48:02 +02001468 ctx = LIST_NEXT(&agent->rt[tid].sending_queue, typeof(ctx), list);
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001469 ret = spoe_prepare_hanotify_frame(appctx, ctx, frame,
1470 SPOE_APPCTX(appctx)->max_frame_size);
1471
1472 }
1473
Christopher Faulet8ef75252017-02-20 22:56:03 +01001474 if (ret > 1)
1475 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001476
Christopher Faulet8ef75252017-02-20 22:56:03 +01001477 switch (ret) {
1478 case -1: /* error */
1479 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1480 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001481
Christopher Faulet8ef75252017-02-20 22:56:03 +01001482 case 0: /* ignore */
1483 if (ctx == NULL)
1484 goto abort_frag_frame;
1485
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001486 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001487 LIST_DEL(&ctx->list);
1488 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001489 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001490 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001491 ctx->spoe_appctx = NULL;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001492 ctx->state = SPOE_CTX_ST_ERROR;
1493 ctx->status_code = (SPOE_APPCTX(appctx)->status_code + 0x100);
1494 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001495 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001496 break;
1497
1498 case 1: /* retry */
1499 *skip = 1;
1500 break;
1501
1502 default:
1503 if (ctx == NULL)
1504 goto abort_frag_frame;
1505
Christopher Fauletf032c3e2017-02-17 15:18:35 +01001506 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001507 LIST_DEL(&ctx->list);
1508 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001509 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001510 spoe_update_stat_time(&ctx->stats.tv_queue, &ctx->stats.t_queue);
Christopher Fauletfce747b2018-01-24 15:59:32 +01001511 ctx->spoe_appctx = SPOE_APPCTX(appctx);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001512 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) ||
1513 (ctx->frag_ctx.flags & SPOE_FRM_FL_FIN))
1514 goto no_frag_frame_sent;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001515 else
Christopher Faulet8ef75252017-02-20 22:56:03 +01001516 goto frag_frame_sent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001517 }
1518 goto end;
1519
1520 frag_frame_sent:
1521 appctx->st0 = SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001522 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001523 SPOE_APPCTX(appctx)->frag_ctx.ctx = ctx;
1524 SPOE_APPCTX(appctx)->frag_ctx.cursid = ctx->stream_id;
1525 SPOE_APPCTX(appctx)->frag_ctx.curfid = ctx->frame_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001526 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
1527 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1528 goto end;
1529
1530 no_frag_frame_sent:
1531 if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_ASYNC) {
1532 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet24289f22017-09-25 14:48:02 +02001533 LIST_ADDQ(&agent->rt[tid].waiting_queue, &ctx->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001534 }
1535 else if (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_PIPELINING) {
1536 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1537 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1538 }
1539 else {
1540 appctx->st0 = SPOE_APPCTX_ST_WAITING_SYNC_ACK;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001541 *skip = 1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001542 LIST_ADDQ(&SPOE_APPCTX(appctx)->waiting_queue, &ctx->list);
1543 }
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001544 _HA_ATOMIC_ADD(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001545 ctx->stats.tv_wait = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001546 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1547 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1548 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001549 SPOE_APPCTX(appctx)->cur_fpa++;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001550
Christopher Faulet8ef75252017-02-20 22:56:03 +01001551 ctx->state = SPOE_CTX_ST_WAITING_ACK;
1552 goto end;
1553
1554 abort_frag_frame:
1555 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1556 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1557 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1558 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1559 goto end;
1560
1561 end:
1562 return ret;
1563}
1564
1565static int
1566spoe_handle_receiving_frame_appctx(struct appctx *appctx, int *skip)
1567{
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02001568 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001569 struct spoe_context *ctx = NULL;
1570 char *frame;
1571 int ret;
1572
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001573 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001574 ret = spoe_recv_frame(appctx, frame,
1575 SPOE_APPCTX(appctx)->max_frame_size);
1576 if (ret > 1) {
1577 if (*frame == SPOE_FRM_T_AGENT_DISCON) {
1578 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001579 ret = -1;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001580 goto end;
1581 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001582 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001583 ret = spoe_handle_agentack_frame(appctx, &ctx, frame, ret);
1584 }
1585 switch (ret) {
1586 case -1: /* error */
1587 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1588 break;
1589
1590 case 0: /* ignore */
1591 break;
1592
1593 case 1: /* retry */
1594 *skip = 1;
1595 break;
1596
1597 default:
1598 LIST_DEL(&ctx->list);
1599 LIST_INIT(&ctx->list);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001600 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01001601 spoe_update_stat_time(&ctx->stats.tv_wait, &ctx->stats.t_waiting);
1602 ctx->stats.tv_response = now;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001603 if (ctx->spoe_appctx) {
1604 ctx->spoe_appctx->cur_fpa--;
Christopher Fauletfce747b2018-01-24 15:59:32 +01001605 ctx->spoe_appctx = NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001606 }
Christopher Faulet8eda93f2017-02-09 09:44:33 +01001607 if (appctx->st0 == SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY &&
1608 ctx == SPOE_APPCTX(appctx)->frag_ctx.ctx) {
1609 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1610 SPOE_APPCTX(appctx)->frag_ctx.ctx = NULL;
1611 SPOE_APPCTX(appctx)->frag_ctx.cursid = 0;
1612 SPOE_APPCTX(appctx)->frag_ctx.curfid = 0;
1613 }
1614 else if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1615 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001616 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
1617 break;
1618 }
1619
1620 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001621 if (trash.data)
1622 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001623 end:
1624 return ret;
1625}
1626
1627static int
1628spoe_handle_processing_appctx(struct appctx *appctx)
1629{
1630 struct stream_interface *si = appctx->owner;
1631 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001632 int ret, skip_sending = 0, skip_receiving = 0, active_s = 0, active_r = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001633
1634 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
1635 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
1636 goto exit;
1637 }
1638
1639 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
1640 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
1641 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
1642 appctx->st1 = SPOE_APPCTX_ERR_NONE;
1643 goto next;
1644 }
1645
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001646 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001647 " - process: fpa=%u/%u - appctx-state=%s - weight=%u - flags=0x%08x\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001648 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8f82b202018-01-24 16:23:03 +01001649 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->cur_fpa,
1650 agent->max_fpa, spoe_appctx_state_str[appctx->st0],
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001651 SPOE_APPCTX(appctx)->node.key, SPOE_APPCTX(appctx)->flags);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001652
Christopher Faulet8f82b202018-01-24 16:23:03 +01001653 if (appctx->st0 == SPOE_APPCTX_ST_WAITING_SYNC_ACK)
1654 skip_sending = 1;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001655
Christopher Faulet8f82b202018-01-24 16:23:03 +01001656 /* receiving_frame loop */
1657 while (!skip_receiving) {
1658 ret = spoe_handle_receiving_frame_appctx(appctx, &skip_receiving);
1659 switch (ret) {
1660 case -1: /* error */
1661 goto next;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001662
Christopher Faulet8f82b202018-01-24 16:23:03 +01001663 case 0: /* ignore */
1664 active_r = 1;
1665 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001666
Christopher Faulet8f82b202018-01-24 16:23:03 +01001667 case 1: /* retry */
1668 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001669
Christopher Faulet8f82b202018-01-24 16:23:03 +01001670 default:
1671 active_r = 1;
1672 break;
1673 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001674 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001675
Christopher Faulet8f82b202018-01-24 16:23:03 +01001676 /* send_frame loop */
1677 while (!skip_sending && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
1678 ret = spoe_handle_sending_frame_appctx(appctx, &skip_sending);
1679 switch (ret) {
1680 case -1: /* error */
1681 goto next;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001682
Christopher Faulet8f82b202018-01-24 16:23:03 +01001683 case 0: /* ignore */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001684 if (SPOE_APPCTX(appctx)->node.key)
1685 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001686 active_s++;
1687 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001688
Christopher Faulet8f82b202018-01-24 16:23:03 +01001689 case 1: /* retry */
1690 break;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001691
Christopher Faulet8f82b202018-01-24 16:23:03 +01001692 default:
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001693 if (SPOE_APPCTX(appctx)->node.key)
1694 SPOE_APPCTX(appctx)->node.key--;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001695 active_s++;
1696 break;
1697 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001698 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001699
Christopher Faulet8f82b202018-01-24 16:23:03 +01001700 if (active_s || active_r) {
Christopher Faulet8f82b202018-01-24 16:23:03 +01001701 update_freq_ctr(&agent->rt[tid].processing_per_sec, active_s);
1702 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1703 }
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001704
Christopher Faulet8f82b202018-01-24 16:23:03 +01001705 if (appctx->st0 == SPOE_APPCTX_ST_PROCESSING && SPOE_APPCTX(appctx)->cur_fpa < agent->max_fpa) {
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001706 _HA_ATOMIC_ADD(&agent->counters.idles, 1);
Christopher Faulet8f82b202018-01-24 16:23:03 +01001707 appctx->st0 = SPOE_APPCTX_ST_IDLE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01001708 eb32_insert(&agent->rt[tid].idle_applets, &SPOE_APPCTX(appctx)->node);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001709 }
1710 return 1;
1711
Christopher Faulet8f82b202018-01-24 16:23:03 +01001712 next:
1713 SPOE_APPCTX(appctx)->task->expire = tick_add_ifset(now_ms, agent->timeout.idle);
1714 return 0;
1715
Christopher Fauleta1cda022016-12-21 08:58:06 +01001716 exit:
1717 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1718 return 0;
1719}
1720
1721static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001722spoe_handle_disconnect_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001723{
1724 struct stream_interface *si = appctx->owner;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001725 struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001726 char *frame, *buf;
1727 int ret;
Christopher Fauletb067b062017-01-04 16:39:11 +01001728
Christopher Fauleta1cda022016-12-21 08:58:06 +01001729 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO)
1730 goto exit;
1731
1732 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT)
1733 goto exit;
1734
Christopher Faulet8ef75252017-02-20 22:56:03 +01001735 /* 4 bytes are reserved at the beginning of <buf> to store the frame
1736 * length. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001737 buf = trash.area; frame = buf+4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001738 ret = spoe_prepare_hadiscon_frame(appctx, frame,
1739 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001740 if (ret > 1)
Christopher Faulet8ef75252017-02-20 22:56:03 +01001741 ret = spoe_send_frame(appctx, buf, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001742
1743 switch (ret) {
1744 case -1: /* error */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001745 case 0: /* ignore => an error, cannot be ignored */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001746 goto exit;
1747
1748 case 1: /* retry */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001749 goto stop;
1750
1751 default:
1752 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1753 " - disconnected by HAProxy (%d): %s\n",
1754 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001755 __FUNCTION__, appctx,
1756 SPOE_APPCTX(appctx)->status_code,
1757 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001758
1759 appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
1760 goto next;
1761 }
1762
1763 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001764 SPOE_APPCTX(appctx)->task->expire =
1765 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001766 return 0;
1767 stop:
1768 return 1;
1769 exit:
1770 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1771 return 0;
1772}
1773
1774static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01001775spoe_handle_disconnecting_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001776{
1777 struct stream_interface *si = appctx->owner;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001778 char *frame;
1779 int ret;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001780
Christopher Fauletb067b062017-01-04 16:39:11 +01001781 if (si->state == SI_ST_CLO || si_opposite(si)->state == SI_ST_CLO) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001782 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001783 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001784 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001785
Christopher Fauletb067b062017-01-04 16:39:11 +01001786 if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001787 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001788 goto exit;
Christopher Fauletb067b062017-01-04 16:39:11 +01001789 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001790
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001791 frame = trash.area; trash.data = 0;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001792 ret = spoe_recv_frame(appctx, frame,
1793 SPOE_APPCTX(appctx)->max_frame_size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001794 if (ret > 1) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001795 trash.data = ret + 4;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001796 ret = spoe_handle_agentdiscon_frame(appctx, frame, ret);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001797 }
1798
1799 switch (ret) {
1800 case -1: /* error */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001801 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1802 " - error on frame (%s)\n",
1803 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001804 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Fauleta1cda022016-12-21 08:58:06 +01001805 __FUNCTION__, appctx,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001806 spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001807 goto exit;
1808
1809 case 0: /* ignore */
Christopher Fauleta1cda022016-12-21 08:58:06 +01001810 goto next;
1811
1812 case 1: /* retry */
1813 goto stop;
1814
1815 default:
Christopher Fauleta1cda022016-12-21 08:58:06 +01001816 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01001817 " - disconnected by peer (%d): %.*s\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01001818 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet42bfa462017-01-04 14:14:19 +01001819 ((struct spoe_agent *)SPOE_APPCTX(appctx)->agent)->id,
Christopher Faulet8ef75252017-02-20 22:56:03 +01001820 __FUNCTION__, appctx, SPOE_APPCTX(appctx)->status_code,
1821 SPOE_APPCTX(appctx)->rlen, SPOE_APPCTX(appctx)->reason);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001822 goto exit;
1823 }
1824
1825 next:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001826 /* Do not forget to remove processed frame from the output buffer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001827 if (trash.data)
1828 co_skip(si_oc(appctx->owner), trash.data);
Christopher Faulet8ef75252017-02-20 22:56:03 +01001829
Christopher Fauleta1cda022016-12-21 08:58:06 +01001830 return 0;
1831 stop:
1832 return 1;
1833 exit:
1834 appctx->st0 = SPOE_APPCTX_ST_EXIT;
1835 return 0;
1836}
1837
1838/* I/O Handler processing messages exchanged with the agent */
1839static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01001840spoe_handle_appctx(struct appctx *appctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01001841{
Christopher Faulet8ef75252017-02-20 22:56:03 +01001842 struct stream_interface *si = appctx->owner;
1843 struct spoe_agent *agent;
1844
1845 if (SPOE_APPCTX(appctx) == NULL)
1846 return;
Christopher Fauleta1cda022016-12-21 08:58:06 +01001847
Christopher Faulet8ef75252017-02-20 22:56:03 +01001848 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
1849 agent = SPOE_APPCTX(appctx)->agent;
Christopher Fauletb067b062017-01-04 16:39:11 +01001850
Christopher Fauleta1cda022016-12-21 08:58:06 +01001851 switchstate:
1852 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: appctx=%p"
1853 " - appctx-state=%s\n",
1854 (int)now.tv_sec, (int)now.tv_usec, agent->id,
1855 __FUNCTION__, appctx, spoe_appctx_state_str[appctx->st0]);
1856
1857 switch (appctx->st0) {
1858 case SPOE_APPCTX_ST_CONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001859 if (spoe_handle_connect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001860 goto out;
1861 goto switchstate;
1862
1863 case SPOE_APPCTX_ST_CONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001864 if (spoe_handle_connecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001865 goto out;
1866 goto switchstate;
1867
1868 case SPOE_APPCTX_ST_IDLE:
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001869 _HA_ATOMIC_SUB(&agent->counters.idles, 1);
Christopher Faulet7d9f1ba2018-02-28 13:33:26 +01001870 eb32_delete(&SPOE_APPCTX(appctx)->node);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001871 if (stopping &&
Christopher Faulet24289f22017-09-25 14:48:02 +02001872 LIST_ISEMPTY(&agent->rt[tid].sending_queue) &&
Christopher Faulet42bfa462017-01-04 14:14:19 +01001873 LIST_ISEMPTY(&SPOE_APPCTX(appctx)->waiting_queue)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01001874 SPOE_APPCTX(appctx)->task->expire =
1875 tick_add_ifset(now_ms, agent->timeout.idle);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001876 appctx->st0 = SPOE_APPCTX_ST_DISCONNECT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001877 goto switchstate;
1878 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001879 appctx->st0 = SPOE_APPCTX_ST_PROCESSING;
1880 /* fall through */
1881
1882 case SPOE_APPCTX_ST_PROCESSING:
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01001883 case SPOE_APPCTX_ST_SENDING_FRAG_NOTIFY:
1884 case SPOE_APPCTX_ST_WAITING_SYNC_ACK:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001885 if (spoe_handle_processing_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001886 goto out;
1887 goto switchstate;
1888
1889 case SPOE_APPCTX_ST_DISCONNECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001890 if (spoe_handle_disconnect_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001891 goto out;
1892 goto switchstate;
1893
1894 case SPOE_APPCTX_ST_DISCONNECTING:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001895 if (spoe_handle_disconnecting_appctx(appctx))
Christopher Fauleta1cda022016-12-21 08:58:06 +01001896 goto out;
1897 goto switchstate;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001898
1899 case SPOE_APPCTX_ST_EXIT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01001900 appctx->st0 = SPOE_APPCTX_ST_END;
1901 SPOE_APPCTX(appctx)->task->expire = TICK_ETERNITY;
1902
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001903 si_shutw(si);
1904 si_shutr(si);
1905 si_ic(si)->flags |= CF_READ_NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001906 /* fall through */
1907
1908 case SPOE_APPCTX_ST_END:
Christopher Fauleta73e59b2016-12-09 17:30:18 +01001909 return;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001910 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01001911 out:
Christopher Faulet24289f22017-09-25 14:48:02 +02001912 if (stopping)
1913 spoe_wakeup_appctx(appctx);
1914
Christopher Faulet42bfa462017-01-04 14:14:19 +01001915 if (SPOE_APPCTX(appctx)->task->expire != TICK_ETERNITY)
1916 task_queue(SPOE_APPCTX(appctx)->task);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001917}
1918
1919struct applet spoe_applet = {
1920 .obj_type = OBJ_TYPE_APPLET,
1921 .name = "<SPOE>", /* used for logging */
Christopher Faulet8ef75252017-02-20 22:56:03 +01001922 .fct = spoe_handle_appctx,
1923 .release = spoe_release_appctx,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001924};
1925
1926/* Create a SPOE applet. On success, the created applet is returned, else
1927 * NULL. */
1928static struct appctx *
Christopher Faulet8ef75252017-02-20 22:56:03 +01001929spoe_create_appctx(struct spoe_config *conf)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001930{
1931 struct appctx *appctx;
1932 struct session *sess;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001933 struct stream *strm;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001934
Emeric Brun1138fd02017-06-19 12:38:55 +02001935 if ((appctx = appctx_new(&spoe_applet, tid_bit)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001936 goto out_error;
1937
Willy Tarreaubafbe012017-11-24 17:34:44 +01001938 appctx->ctx.spoe.ptr = pool_alloc_dirty(pool_head_spoe_appctx);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001939 if (SPOE_APPCTX(appctx) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001940 goto out_free_appctx;
Willy Tarreaubafbe012017-11-24 17:34:44 +01001941 memset(appctx->ctx.spoe.ptr, 0, pool_head_spoe_appctx->size);
Christopher Fauleta1cda022016-12-21 08:58:06 +01001942
Christopher Faulet42bfa462017-01-04 14:14:19 +01001943 appctx->st0 = SPOE_APPCTX_ST_CONNECT;
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01001944 if ((SPOE_APPCTX(appctx)->task = task_new(tid_bit)) == NULL)
Christopher Faulet42bfa462017-01-04 14:14:19 +01001945 goto out_free_spoe_appctx;
1946
1947 SPOE_APPCTX(appctx)->owner = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001948 SPOE_APPCTX(appctx)->task->process = spoe_process_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001949 SPOE_APPCTX(appctx)->task->context = appctx;
1950 SPOE_APPCTX(appctx)->agent = conf->agent;
1951 SPOE_APPCTX(appctx)->version = 0;
1952 SPOE_APPCTX(appctx)->max_frame_size = conf->agent->max_frame_size;
1953 SPOE_APPCTX(appctx)->flags = 0;
Christopher Fauletb067b062017-01-04 16:39:11 +01001954 SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001955 SPOE_APPCTX(appctx)->buffer = BUF_NULL;
Christopher Faulet8f82b202018-01-24 16:23:03 +01001956 SPOE_APPCTX(appctx)->cur_fpa = 0;
Christopher Faulet4596fb72017-01-11 14:05:19 +01001957
Willy Tarreau21046592020-02-26 10:39:36 +01001958 MT_LIST_INIT(&SPOE_APPCTX(appctx)->buffer_wait.list);
Christopher Faulet4596fb72017-01-11 14:05:19 +01001959 SPOE_APPCTX(appctx)->buffer_wait.target = appctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01001960 SPOE_APPCTX(appctx)->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01001961
1962 LIST_INIT(&SPOE_APPCTX(appctx)->list);
1963 LIST_INIT(&SPOE_APPCTX(appctx)->waiting_queue);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001964
Willy Tarreau5820a362016-12-22 15:59:02 +01001965 sess = session_new(&conf->agent_fe, NULL, &appctx->obj_type);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001966 if (!sess)
1967 goto out_free_spoe;
1968
Willy Tarreau87787ac2017-08-28 16:22:54 +02001969 if ((strm = stream_new(sess, &appctx->obj_type)) == NULL)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001970 goto out_free_sess;
1971
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001972 stream_set_backend(strm, conf->agent->b.be);
1973
1974 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001975 si_cant_get(&strm->si[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001976 appctx_wakeup(appctx);
1977
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001978 strm->do_log = NULL;
1979 strm->res.flags |= CF_READ_DONTWAIT;
1980
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001981 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02001982 LIST_ADDQ(&conf->agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001983 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
Olivier Houchard9e7ae282019-03-08 18:50:42 +01001984 _HA_ATOMIC_ADD(&conf->agent->counters.applets, 1);
Emeric Brun5f77fef2017-05-29 15:26:51 +02001985
Emeric Brunc60def82017-09-27 14:59:38 +02001986 task_wakeup(SPOE_APPCTX(appctx)->task, TASK_WOKEN_INIT);
Willy Tarreau87787ac2017-08-28 16:22:54 +02001987 task_wakeup(strm->task, TASK_WOKEN_INIT);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001988 return appctx;
1989
1990 /* Error unrolling */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001991 out_free_sess:
1992 session_free(sess);
1993 out_free_spoe:
Olivier Houchard3f795f72019-04-17 22:51:06 +02001994 task_destroy(SPOE_APPCTX(appctx)->task);
Christopher Faulet42bfa462017-01-04 14:14:19 +01001995 out_free_spoe_appctx:
Willy Tarreaubafbe012017-11-24 17:34:44 +01001996 pool_free(pool_head_spoe_appctx, SPOE_APPCTX(appctx));
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001997 out_free_appctx:
1998 appctx_free(appctx);
1999 out_error:
2000 return NULL;
2001}
2002
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002003static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002004spoe_queue_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002005{
2006 struct spoe_config *conf = FLT_CONF(ctx->filter);
2007 struct spoe_agent *agent = conf->agent;
2008 struct appctx *appctx;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002009 struct spoe_appctx *spoe_appctx;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002010
Christopher Fauleta1cda022016-12-21 08:58:06 +01002011 /* Check if we need to create a new SPOE applet or not. */
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002012 if (!eb_is_empty(&agent->rt[tid].idle_applets) &&
Christopher Fauleteccfa612020-06-22 15:32:14 +02002013 (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 +01002014 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002015
2016 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauleta1cda022016-12-21 08:58:06 +01002017 " - try to create new SPOE appctx\n",
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002018 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
2019 ctx->strm);
2020
Christopher Fauleta1cda022016-12-21 08:58:06 +01002021 /* Do not try to create a new applet if there is no server up for the
2022 * agent's backend. */
2023 if (!agent->b.be->srv_act && !agent->b.be->srv_bck) {
2024 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2025 " - cannot create SPOE appctx: no server up\n",
2026 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2027 __FUNCTION__, ctx->strm);
2028 goto end;
2029 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002030
Christopher Fauleta1cda022016-12-21 08:58:06 +01002031 /* Do not try to create a new applet if we have reached the maximum of
2032 * connection per seconds */
Christopher Faulet48026722016-11-16 15:01:12 +01002033 if (agent->cps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002034 if (!freq_ctr_remain(&agent->rt[tid].conn_per_sec, agent->cps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002035 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2036 " - cannot create SPOE appctx: max CPS reached\n",
2037 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2038 __FUNCTION__, ctx->strm);
2039 goto end;
2040 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002041 }
2042
Christopher Faulet8ef75252017-02-20 22:56:03 +01002043 appctx = spoe_create_appctx(conf);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002044 if (appctx == NULL) {
2045 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2046 " - failed to create SPOE appctx\n",
2047 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2048 __FUNCTION__, ctx->strm);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02002049 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01002050 "SPOE: [%s] failed to create SPOE applet\n",
2051 agent->id);
2052
Christopher Fauleta1cda022016-12-21 08:58:06 +01002053 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002054 }
2055
Christopher Fauleta1cda022016-12-21 08:58:06 +01002056 /* Increase the per-process number of cumulated connections */
2057 if (agent->cps_max > 0)
Christopher Faulet24289f22017-09-25 14:48:02 +02002058 update_freq_ctr(&agent->rt[tid].conn_per_sec, 1);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002059
Christopher Fauleta1cda022016-12-21 08:58:06 +01002060 end:
2061 /* The only reason to return an error is when there is no applet */
Christopher Faulet24289f22017-09-25 14:48:02 +02002062 if (LIST_ISEMPTY(&agent->rt[tid].applets)) {
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002063 ctx->status_code = SPOE_CTX_ERR_RES;
2064 return -1;
2065 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002066
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002067 /* Add the SPOE context in the sending queue if the stream has no applet
2068 * already assigned and wakeup all idle applets. Otherwise, don't queue
2069 * it. */
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002070 _HA_ATOMIC_ADD(&agent->counters.nb_sending, 1);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002071 spoe_update_stat_time(&ctx->stats.tv_request, &ctx->stats.t_request);
2072 ctx->stats.tv_queue = now;
Christopher Faulet3e86cec2019-04-10 14:02:12 +02002073 if (ctx->spoe_appctx)
2074 return 1;
2075 LIST_ADDQ(&agent->rt[tid].sending_queue, &ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002076
2077 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002078 " - Add stream in sending queue"
Christopher Faulet68db0232018-04-06 11:34:12 +02002079 " - applets=%u - idles=%u - processing=%u\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002080 (int)now.tv_sec, (int)now.tv_usec, agent->id, __FUNCTION__,
Christopher Faulet68db0232018-04-06 11:34:12 +02002081 ctx->strm, agent->counters.applets, agent->counters.idles,
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002082 agent->rt[tid].processing);
Christopher Fauletf7a30922016-11-10 15:04:51 +01002083
Christopher Fauletb077cdc2018-01-24 16:37:57 +01002084 /* Finally try to wakeup an IDLE applet. */
2085 if (!eb_is_empty(&agent->rt[tid].idle_applets)) {
2086 struct eb32_node *node;
2087
2088 node = eb32_first(&agent->rt[tid].idle_applets);
2089 spoe_appctx = eb32_entry(node, struct spoe_appctx, node);
2090 if (node && spoe_appctx) {
2091 eb32_delete(&spoe_appctx->node);
2092 spoe_appctx->node.key++;
2093 eb32_insert(&agent->rt[tid].idle_applets, &spoe_appctx->node);
2094 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002095 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002096 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002097 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002098}
2099
2100/***************************************************************************
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002101 * Functions that encode SPOE messages
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002102 **************************************************************************/
Christopher Faulet10e37672017-09-21 16:38:22 +02002103/* Encode a SPOE message. Info in <ctx->frag_ctx>, if any, are used to handle
2104 * fragmented_content. If the next message can be processed, it returns 0. If
2105 * the message is too big, it returns -1.*/
2106static int
2107spoe_encode_message(struct stream *s, struct spoe_context *ctx,
2108 struct spoe_message *msg, int dir,
2109 char **buf, char *end)
2110{
2111 struct sample *smp;
2112 struct spoe_arg *arg;
2113 int ret;
2114
2115 if (msg->cond) {
2116 ret = acl_exec_cond(msg->cond, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2117 ret = acl_pass(ret);
2118 if (msg->cond->pol == ACL_COND_UNLESS)
2119 ret = !ret;
2120
2121 /* the rule does not match */
2122 if (!ret)
2123 goto next;
2124 }
2125
2126 /* Resume encoding of a SPOE argument */
2127 if (ctx->frag_ctx.curarg != NULL) {
2128 arg = ctx->frag_ctx.curarg;
2129 goto encode_argument;
2130 }
2131
2132 if (ctx->frag_ctx.curoff != UINT_MAX)
2133 goto encode_msg_payload;
2134
2135 /* Check if there is enough space for the message name and the
2136 * number of arguments. It implies <msg->id_len> is encoded on 2
2137 * bytes, at most (< 2288). */
2138 if (*buf + 2 + msg->id_len + 1 > end)
2139 goto too_big;
2140
2141 /* Encode the message name */
2142 if (spoe_encode_buffer(msg->id, msg->id_len, buf, end) == -1)
2143 goto too_big;
2144
2145 /* Set the number of arguments for this message */
2146 **buf = msg->nargs;
2147 (*buf)++;
2148
2149 ctx->frag_ctx.curoff = 0;
2150 encode_msg_payload:
2151
2152 /* Loop on arguments */
2153 list_for_each_entry(arg, &msg->args, list) {
2154 ctx->frag_ctx.curarg = arg;
2155 ctx->frag_ctx.curoff = UINT_MAX;
Kevin Zhuf7f54282019-04-26 14:00:01 +08002156 ctx->frag_ctx.curlen = 0;
Christopher Faulet10e37672017-09-21 16:38:22 +02002157
2158 encode_argument:
2159 if (ctx->frag_ctx.curoff != UINT_MAX)
2160 goto encode_arg_value;
2161
Joseph Herlantf7f60312018-11-15 13:46:49 -08002162 /* Encode the argument name as a string. It can by NULL */
Christopher Faulet10e37672017-09-21 16:38:22 +02002163 if (spoe_encode_buffer(arg->name, arg->name_len, buf, end) == -1)
2164 goto too_big;
2165
2166 ctx->frag_ctx.curoff = 0;
2167 encode_arg_value:
2168
Joseph Herlantf7f60312018-11-15 13:46:49 -08002169 /* Fetch the argument value */
Christopher Faulet10e37672017-09-21 16:38:22 +02002170 smp = sample_process(s->be, s->sess, s, dir|SMP_OPT_FINAL, arg->expr, NULL);
Christopher Faulet3b1d0042019-05-06 09:53:10 +02002171 if (smp) {
2172 smp->ctx.a[0] = &ctx->frag_ctx.curlen;
2173 smp->ctx.a[1] = &ctx->frag_ctx.curoff;
2174 }
Christopher Faulet85db3212019-04-26 14:30:15 +02002175 ret = spoe_encode_data(smp, buf, end);
Christopher Faulet10e37672017-09-21 16:38:22 +02002176 if (ret == -1 || ctx->frag_ctx.curoff)
2177 goto too_big;
2178 }
2179
2180 next:
2181 return 0;
2182
2183 too_big:
2184 return -1;
2185}
2186
Christopher Fauletc718b822017-09-21 16:50:56 +02002187/* Encode list of SPOE messages. Info in <ctx->frag_ctx>, if any, are used to
2188 * handle fragmented content. On success it returns 1. If an error occurred, -1
2189 * is returned. If nothing has been encoded, it returns 0 (this is only possible
2190 * for unfragmented payload). */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002191static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002192spoe_encode_messages(struct stream *s, struct spoe_context *ctx,
Christopher Fauletc718b822017-09-21 16:50:56 +02002193 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002194{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002195 struct spoe_config *conf = FLT_CONF(ctx->filter);
2196 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002197 struct spoe_message *msg;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002198 char *p, *end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002199
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002200 p = b_head(&ctx->buffer);
Christopher Faulet24289f22017-09-25 14:48:02 +02002201 end = p + agent->rt[tid].frame_size - FRAME_HDR_SIZE;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002202
Christopher Fauletc718b822017-09-21 16:50:56 +02002203 if (type == SPOE_MSGS_BY_EVENT) { /* Loop on messages by event */
2204 /* Resume encoding of a SPOE message */
2205 if (ctx->frag_ctx.curmsg != NULL) {
2206 msg = ctx->frag_ctx.curmsg;
2207 goto encode_evt_message;
2208 }
2209
2210 list_for_each_entry(msg, messages, by_evt) {
2211 ctx->frag_ctx.curmsg = msg;
2212 ctx->frag_ctx.curarg = NULL;
2213 ctx->frag_ctx.curoff = UINT_MAX;
2214
2215 encode_evt_message:
2216 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2217 goto too_big;
2218 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002219 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002220 else if (type == SPOE_MSGS_BY_GROUP) { /* Loop on messages by group */
2221 /* Resume encoding of a SPOE message */
2222 if (ctx->frag_ctx.curmsg != NULL) {
2223 msg = ctx->frag_ctx.curmsg;
2224 goto encode_grp_message;
2225 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002226
Christopher Fauletc718b822017-09-21 16:50:56 +02002227 list_for_each_entry(msg, messages, by_grp) {
2228 ctx->frag_ctx.curmsg = msg;
2229 ctx->frag_ctx.curarg = NULL;
2230 ctx->frag_ctx.curoff = UINT_MAX;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002231
Christopher Fauletc718b822017-09-21 16:50:56 +02002232 encode_grp_message:
2233 if (spoe_encode_message(s, ctx, msg, dir, &p, end) == -1)
2234 goto too_big;
2235 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002236 }
Christopher Fauletc718b822017-09-21 16:50:56 +02002237 else
2238 goto skip;
2239
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002240
Christopher Faulet57583e42017-09-04 15:41:09 +02002241 /* nothing has been encoded for an unfragmented payload */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002242 if (!(ctx->flags & SPOE_CTX_FL_FRAGMENTED) && p == b_head(&ctx->buffer))
Christopher Faulet57583e42017-09-04 15:41:09 +02002243 goto skip;
2244
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002245 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002246 " - encode %s messages - spoe_appctx=%p"
2247 "- max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002248 (int)now.tv_sec, (int)now.tv_usec,
2249 agent->id, __FUNCTION__, s,
2250 ((ctx->flags & SPOE_CTX_FL_FRAGMENTED) ? "last fragment of" : "unfragmented"),
Christopher Fauletfce747b2018-01-24 15:59:32 +01002251 ctx->spoe_appctx, (agent->rt[tid].frame_size - FRAME_HDR_SIZE),
Christopher Faulet45073512018-07-20 10:16:29 +02002252 p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002253
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002254 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002255 ctx->frag_ctx.curmsg = NULL;
2256 ctx->frag_ctx.curarg = NULL;
2257 ctx->frag_ctx.curoff = 0;
2258 ctx->frag_ctx.flags = SPOE_FRM_FL_FIN;
Christopher Faulet57583e42017-09-04 15:41:09 +02002259
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002260 return 1;
2261
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002262 too_big:
Christopher Fauleta715ea82019-04-10 14:21:51 +02002263 /* Return an error if fragmentation is unsupported or if nothing has
2264 * been encoded because its too big and not splittable. */
2265 if (!(agent->flags & SPOE_FL_SND_FRAGMENTATION) || p == b_head(&ctx->buffer)) {
Christopher Fauletcecd8522017-02-24 22:11:21 +01002266 ctx->status_code = SPOE_CTX_ERR_TOO_BIG;
2267 return -1;
2268 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002269
2270 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet8ef75252017-02-20 22:56:03 +01002271 " - encode fragmented messages - spoe_appctx=%p"
2272 " - curmsg=%p - curarg=%p - curoff=%u"
2273 " - max_size=%u - encoded=%ld\n",
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002274 (int)now.tv_sec, (int)now.tv_usec,
Christopher Fauletfce747b2018-01-24 15:59:32 +01002275 agent->id, __FUNCTION__, s, ctx->spoe_appctx,
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002276 ctx->frag_ctx.curmsg, ctx->frag_ctx.curarg, ctx->frag_ctx.curoff,
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002277 (agent->rt[tid].frame_size - FRAME_HDR_SIZE), p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002278
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002279 b_set_data(&ctx->buffer, p - b_head(&ctx->buffer));
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002280 ctx->flags |= SPOE_CTX_FL_FRAGMENTED;
2281 ctx->frag_ctx.flags &= ~SPOE_FRM_FL_FIN;
2282 return 1;
Christopher Faulet57583e42017-09-04 15:41:09 +02002283
2284 skip:
2285 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2286 " - skip the frame because nothing has been encoded\n",
2287 (int)now.tv_sec, (int)now.tv_usec,
2288 agent->id, __FUNCTION__, s);
2289 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002290}
2291
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002292
2293/***************************************************************************
2294 * Functions that handle SPOE actions
2295 **************************************************************************/
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002296/* Helper function to set a variable */
2297static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002298spoe_set_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002299 struct sample *smp)
2300{
2301 struct spoe_config *conf = FLT_CONF(ctx->filter);
2302 struct spoe_agent *agent = conf->agent;
2303 char varname[64];
2304
2305 memset(varname, 0, sizeof(varname));
2306 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2307 scope, agent->var_pfx, len, name);
Etienne Carriereaec89892017-12-14 09:36:40 +00002308 if (agent->flags & SPOE_FL_FORCE_SET_VAR)
2309 vars_set_by_name(varname, len, smp);
2310 else
2311 vars_set_by_name_ifexist(varname, len, smp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002312}
2313
2314/* Helper function to unset a variable */
2315static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002316spoe_unset_var(struct spoe_context *ctx, char *scope, char *name, int len,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002317 struct sample *smp)
2318{
2319 struct spoe_config *conf = FLT_CONF(ctx->filter);
2320 struct spoe_agent *agent = conf->agent;
2321 char varname[64];
2322
2323 memset(varname, 0, sizeof(varname));
2324 len = snprintf(varname, sizeof(varname), "%s.%s.%.*s",
2325 scope, agent->var_pfx, len, name);
2326 vars_unset_by_name_ifexist(varname, len, smp);
2327}
2328
2329
Christopher Faulet8ef75252017-02-20 22:56:03 +01002330static inline int
2331spoe_decode_action_set_var(struct stream *s, struct spoe_context *ctx,
2332 char **buf, char *end, int dir)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002333{
Christopher Faulet8ef75252017-02-20 22:56:03 +01002334 char *str, *scope, *p = *buf;
2335 struct sample smp;
2336 uint64_t sz;
2337 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002338
Christopher Faulet8ef75252017-02-20 22:56:03 +01002339 if (p + 2 >= end)
2340 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002341
Christopher Faulet8ef75252017-02-20 22:56:03 +01002342 /* SET-VAR requires 3 arguments */
2343 if (*p++ != 3)
2344 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002345
Christopher Faulet8ef75252017-02-20 22:56:03 +01002346 switch (*p++) {
2347 case SPOE_SCOPE_PROC: scope = "proc"; break;
2348 case SPOE_SCOPE_SESS: scope = "sess"; break;
2349 case SPOE_SCOPE_TXN : scope = "txn"; break;
2350 case SPOE_SCOPE_REQ : scope = "req"; break;
2351 case SPOE_SCOPE_RES : scope = "res"; break;
2352 default: goto skip;
2353 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002354
Christopher Faulet8ef75252017-02-20 22:56:03 +01002355 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2356 goto skip;
2357 memset(&smp, 0, sizeof(smp));
2358 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002359
Christopher Faulet8ef75252017-02-20 22:56:03 +01002360 if (spoe_decode_data(&p, end, &smp) == -1)
2361 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002362
Christopher Faulet8ef75252017-02-20 22:56:03 +01002363 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2364 " - set-var '%s.%s.%.*s'\n",
2365 (int)now.tv_sec, (int)now.tv_usec,
2366 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2367 __FUNCTION__, s, scope,
2368 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2369 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002370
Christopher Faulet8ef75252017-02-20 22:56:03 +01002371 spoe_set_var(ctx, scope, str, sz, &smp);
Christopher Fauletb5cff602016-11-24 14:53:22 +01002372
Christopher Faulet8ef75252017-02-20 22:56:03 +01002373 ret = (p - *buf);
2374 *buf = p;
2375 return ret;
2376 skip:
2377 return 0;
2378}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002379
Christopher Faulet8ef75252017-02-20 22:56:03 +01002380static inline int
2381spoe_decode_action_unset_var(struct stream *s, struct spoe_context *ctx,
2382 char **buf, char *end, int dir)
2383{
2384 char *str, *scope, *p = *buf;
2385 struct sample smp;
2386 uint64_t sz;
2387 int ret;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002388
Christopher Faulet8ef75252017-02-20 22:56:03 +01002389 if (p + 2 >= end)
2390 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002391
Christopher Faulet8ef75252017-02-20 22:56:03 +01002392 /* UNSET-VAR requires 2 arguments */
2393 if (*p++ != 2)
2394 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002395
Christopher Faulet8ef75252017-02-20 22:56:03 +01002396 switch (*p++) {
2397 case SPOE_SCOPE_PROC: scope = "proc"; break;
2398 case SPOE_SCOPE_SESS: scope = "sess"; break;
2399 case SPOE_SCOPE_TXN : scope = "txn"; break;
2400 case SPOE_SCOPE_REQ : scope = "req"; break;
2401 case SPOE_SCOPE_RES : scope = "res"; break;
2402 default: goto skip;
2403 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002404
Christopher Faulet8ef75252017-02-20 22:56:03 +01002405 if (spoe_decode_buffer(&p, end, &str, &sz) == -1)
2406 goto skip;
2407 memset(&smp, 0, sizeof(smp));
2408 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002409
Christopher Faulet8ef75252017-02-20 22:56:03 +01002410 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2411 " - unset-var '%s.%s.%.*s'\n",
2412 (int)now.tv_sec, (int)now.tv_usec,
2413 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->id,
2414 __FUNCTION__, s, scope,
2415 ((struct spoe_config *)FLT_CONF(ctx->filter))->agent->var_pfx,
2416 (int)sz, str);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002417
Christopher Faulet8ef75252017-02-20 22:56:03 +01002418 spoe_unset_var(ctx, scope, str, sz, &smp);
2419
2420 ret = (p - *buf);
2421 *buf = p;
2422 return ret;
2423 skip:
2424 return 0;
2425}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002426
Christopher Faulet8ef75252017-02-20 22:56:03 +01002427/* Process SPOE actions for a specific event. It returns 1 on success. If an
2428 * error occurred, 0 is returned. */
2429static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002430spoe_process_actions(struct stream *s, struct spoe_context *ctx, int dir)
Christopher Faulet8ef75252017-02-20 22:56:03 +01002431{
2432 char *p, *end;
2433 int ret;
2434
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002435 p = b_head(&ctx->buffer);
2436 end = p + b_data(&ctx->buffer);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002437
2438 while (p < end) {
2439 enum spoe_action_type type;
2440
2441 type = *p++;
2442 switch (type) {
2443 case SPOE_ACT_T_SET_VAR:
2444 ret = spoe_decode_action_set_var(s, ctx, &p, end, dir);
2445 if (!ret)
2446 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002447 break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002448
Christopher Faulet8ef75252017-02-20 22:56:03 +01002449 case SPOE_ACT_T_UNSET_VAR:
2450 ret = spoe_decode_action_unset_var(s, ctx, &p, end, dir);
2451 if (!ret)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002452 goto skip;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002453 break;
2454
2455 default:
2456 goto skip;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002457 }
2458 }
2459
2460 return 1;
2461 skip:
2462 return 0;
2463}
2464
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002465/***************************************************************************
2466 * Functions that process SPOE events
2467 **************************************************************************/
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002468static void
2469spoe_update_stats(struct stream *s, struct spoe_agent *agent,
2470 struct spoe_context *ctx, int dir)
2471{
2472 if (!tv_iszero(&ctx->stats.tv_start)) {
2473 spoe_update_stat_time(&ctx->stats.tv_start, &ctx->stats.t_process);
2474 ctx->stats.t_total += ctx->stats.t_process;
2475 tv_zero(&ctx->stats.tv_request);
2476 tv_zero(&ctx->stats.tv_queue);
2477 tv_zero(&ctx->stats.tv_wait);
2478 tv_zero(&ctx->stats.tv_response);
2479 }
2480
2481 if (agent->var_t_process) {
2482 struct sample smp;
2483
2484 memset(&smp, 0, sizeof(smp));
2485 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2486 smp.data.u.sint = ctx->stats.t_process;
2487 smp.data.type = SMP_T_SINT;
2488
2489 spoe_set_var(ctx, "txn", agent->var_t_process,
2490 strlen(agent->var_t_process), &smp);
2491 }
2492
2493 if (agent->var_t_total) {
2494 struct sample smp;
2495
2496 memset(&smp, 0, sizeof(smp));
2497 smp_set_owner(&smp, s->be, s->sess, s, dir|SMP_OPT_FINAL);
2498 smp.data.u.sint = ctx->stats.t_total;
2499 smp.data.type = SMP_T_SINT;
2500
2501 spoe_set_var(ctx, "txn", agent->var_t_total,
2502 strlen(agent->var_t_total), &smp);
2503 }
2504}
2505
2506static void
2507spoe_handle_processing_error(struct stream *s, struct spoe_agent *agent,
2508 struct spoe_context *ctx, int dir)
2509{
2510 if (agent->eps_max > 0)
2511 update_freq_ctr(&agent->rt[tid].err_per_sec, 1);
2512
2513 if (agent->var_on_error) {
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->status_code;
2519 smp.data.type = SMP_T_BOOL;
2520
2521 spoe_set_var(ctx, "txn", agent->var_on_error,
2522 strlen(agent->var_on_error), &smp);
2523 }
2524
2525 ctx->state = ((agent->flags & SPOE_FL_CONT_ON_ERR)
2526 ? SPOE_CTX_ST_READY
2527 : SPOE_CTX_ST_NONE);
2528}
2529
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002530static inline int
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002531spoe_start_processing(struct spoe_agent *agent, struct spoe_context *ctx, int dir)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002532{
Christopher Fauleta1cda022016-12-21 08:58:06 +01002533 /* If a process is already started for this SPOE context, retry
2534 * later. */
2535 if (ctx->flags & SPOE_CTX_FL_PROCESS)
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002536 return 0;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002537
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002538 agent->rt[tid].processing++;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002539 ctx->stats.tv_start = now;
2540 ctx->stats.tv_request = now;
2541 ctx->stats.t_request = -1;
2542 ctx->stats.t_queue = -1;
2543 ctx->stats.t_waiting = -1;
2544 ctx->stats.t_response = -1;
2545 ctx->stats.t_process = -1;
2546
2547 ctx->status_code = 0;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002548
Christopher Fauleta1cda022016-12-21 08:58:06 +01002549 /* Set the right flag to prevent request and response processing
2550 * in same time. */
2551 ctx->flags |= ((dir == SMP_OPT_DIR_REQ)
2552 ? SPOE_CTX_FL_REQ_PROCESS
2553 : SPOE_CTX_FL_RSP_PROCESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002554 return 1;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002555}
2556
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002557static inline void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002558spoe_stop_processing(struct spoe_agent *agent, struct spoe_context *ctx)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002559{
Christopher Fauletfce747b2018-01-24 15:59:32 +01002560 struct spoe_appctx *sa = ctx->spoe_appctx;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002561
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002562 if (!(ctx->flags & SPOE_CTX_FL_PROCESS))
2563 return;
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002564 _HA_ATOMIC_ADD(&agent->counters.nb_processed, 1);
Christopher Faulet879dca92018-03-23 11:53:24 +01002565 if (sa) {
2566 if (sa->frag_ctx.ctx == ctx) {
2567 sa->frag_ctx.ctx = NULL;
2568 spoe_wakeup_appctx(sa->owner);
2569 }
2570 else
2571 sa->cur_fpa--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002572 }
2573
Christopher Fauleta1cda022016-12-21 08:58:06 +01002574 /* Reset the flag to allow next processing */
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002575 agent->rt[tid].processing--;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002576 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002577
2578 /* Reset processing timer */
2579 ctx->process_exp = TICK_ETERNITY;
2580
Christopher Faulet8ef75252017-02-20 22:56:03 +01002581 spoe_release_buffer(&ctx->buffer, &ctx->buffer_wait);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002582
Christopher Fauletfce747b2018-01-24 15:59:32 +01002583 ctx->spoe_appctx = NULL;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002584 ctx->frag_ctx.curmsg = NULL;
2585 ctx->frag_ctx.curarg = NULL;
2586 ctx->frag_ctx.curoff = 0;
2587 ctx->frag_ctx.flags = 0;
2588
Christopher Fauleta1cda022016-12-21 08:58:06 +01002589 if (!LIST_ISEMPTY(&ctx->list)) {
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002590 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS)
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002591 _HA_ATOMIC_SUB(&agent->counters.nb_sending, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002592 else
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002593 _HA_ATOMIC_SUB(&agent->counters.nb_waiting, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002594
Christopher Fauleta1cda022016-12-21 08:58:06 +01002595 LIST_DEL(&ctx->list);
2596 LIST_INIT(&ctx->list);
2597 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002598}
2599
Christopher Faulet58d03682017-09-21 16:57:24 +02002600/* Process a list of SPOE messages. First, this functions will process messages
2601 * and send them to an agent in a NOTIFY frame. Then, it will wait a ACK frame
2602 * to process corresponding actions. During all the processing, it returns 0
2603 * and it returns 1 when the processing is finished. If an error occurred, -1
2604 * is returned. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002605static int
Christopher Faulet58d03682017-09-21 16:57:24 +02002606spoe_process_messages(struct stream *s, struct spoe_context *ctx,
2607 struct list *messages, int dir, int type)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002608{
Christopher Fauletf7a30922016-11-10 15:04:51 +01002609 struct spoe_config *conf = FLT_CONF(ctx->filter);
2610 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002611 int ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002612
2613 if (ctx->state == SPOE_CTX_ST_ERROR)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002614 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002615
2616 if (tick_is_expired(ctx->process_exp, now_ms) && ctx->state != SPOE_CTX_ST_DONE) {
2617 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002618 " - failed to process messages: timeout\n",
Christopher Fauletf7a30922016-11-10 15:04:51 +01002619 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002620 agent->id, __FUNCTION__, s);
Christopher Fauletb067b062017-01-04 16:39:11 +01002621 ctx->status_code = SPOE_CTX_ERR_TOUT;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002622 goto end;
Christopher Fauletf7a30922016-11-10 15:04:51 +01002623 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002624
2625 if (ctx->state == SPOE_CTX_ST_READY) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002626 if (agent->eps_max > 0) {
Christopher Faulet24289f22017-09-25 14:48:02 +02002627 if (!freq_ctr_remain(&agent->rt[tid].err_per_sec, agent->eps_max, 0)) {
Christopher Fauleta1cda022016-12-21 08:58:06 +01002628 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet58d03682017-09-21 16:57:24 +02002629 " - skip processing of messages: max EPS reached\n",
Christopher Fauleta1cda022016-12-21 08:58:06 +01002630 (int)now.tv_sec, (int)now.tv_usec,
Christopher Faulet58d03682017-09-21 16:57:24 +02002631 agent->id, __FUNCTION__, s);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002632 goto skip;
2633 }
2634 }
2635
Christopher Fauletf7a30922016-11-10 15:04:51 +01002636 if (!tick_isset(ctx->process_exp)) {
2637 ctx->process_exp = tick_add_ifset(now_ms, agent->timeout.processing);
2638 s->task->expire = tick_first((tick_is_expired(s->task->expire, now_ms) ? 0 : s->task->expire),
2639 ctx->process_exp);
2640 }
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002641 ret = spoe_start_processing(agent, ctx, dir);
Christopher Fauletb067b062017-01-04 16:39:11 +01002642 if (!ret)
2643 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002644
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002645 ctx->state = SPOE_CTX_ST_ENCODING_MSGS;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002646 /* fall through */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002647 }
2648
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002649 if (ctx->state == SPOE_CTX_ST_ENCODING_MSGS) {
Christopher Faulet63263e52019-04-10 14:47:18 +02002650 if (tv_iszero(&ctx->stats.tv_request))
2651 ctx->stats.tv_request = now;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002652 if (!spoe_acquire_buffer(&ctx->buffer, &ctx->buffer_wait))
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002653 goto out;
Christopher Faulet58d03682017-09-21 16:57:24 +02002654 ret = spoe_encode_messages(s, ctx, messages, dir, type);
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002655 if (ret < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002656 goto end;
Christopher Faulet57583e42017-09-04 15:41:09 +02002657 if (!ret)
2658 goto skip;
Christopher Faulet333694d2018-01-12 10:45:47 +01002659 if (spoe_queue_context(ctx) < 0)
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002660 goto end;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002661 ctx->state = SPOE_CTX_ST_SENDING_MSGS;
2662 }
2663
2664 if (ctx->state == SPOE_CTX_ST_SENDING_MSGS) {
Christopher Fauletfce747b2018-01-24 15:59:32 +01002665 if (ctx->spoe_appctx)
2666 spoe_wakeup_appctx(ctx->spoe_appctx->owner);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002667 ret = 0;
2668 goto out;
2669 }
2670
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01002671 if (ctx->state == SPOE_CTX_ST_WAITING_ACK) {
2672 ret = 0;
2673 goto out;
2674 }
2675
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002676 if (ctx->state == SPOE_CTX_ST_DONE) {
Christopher Faulet58d03682017-09-21 16:57:24 +02002677 spoe_process_actions(s, ctx, dir);
Christopher Faulet8ef75252017-02-20 22:56:03 +01002678 ret = 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002679 ctx->frame_id++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002680 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002681 spoe_update_stat_time(&ctx->stats.tv_response, &ctx->stats.t_response);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002682 goto end;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002683 }
2684
2685 out:
2686 return ret;
2687
Christopher Fauleta1cda022016-12-21 08:58:06 +01002688 skip:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002689 tv_zero(&ctx->stats.tv_start);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002690 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002691 spoe_stop_processing(agent, ctx);
2692 return 1;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002693
Christopher Fauleta1cda022016-12-21 08:58:06 +01002694 end:
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002695 spoe_update_stats(s, agent, ctx, dir);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002696 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002697 if (ctx->status_code) {
Olivier Houchard9e7ae282019-03-08 18:50:42 +01002698 _HA_ATOMIC_ADD(&agent->counters.nb_errors, 1);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002699 spoe_handle_processing_error(s, agent, ctx, dir);
2700 ret = 1;
2701 }
Christopher Faulet58d03682017-09-21 16:57:24 +02002702 return ret;
2703}
2704
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002705/* Process a SPOE group, ie the list of messages attached to the group <grp>.
2706 * See spoe_process_message for details. */
2707static int
2708spoe_process_group(struct stream *s, struct spoe_context *ctx,
2709 struct spoe_group *group, int dir)
2710{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002711 struct spoe_config *conf = FLT_CONF(ctx->filter);
2712 struct spoe_agent *agent = conf->agent;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002713 int ret;
2714
2715 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
2716 " - ctx-state=%s - Process messages for group=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002717 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002718 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2719 group->id);
2720
2721 if (LIST_ISEMPTY(&group->messages))
2722 return 1;
2723
2724 ret = spoe_process_messages(s, ctx, &group->messages, dir, SPOE_MSGS_BY_GROUP);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002725 if (ret && ctx->stats.t_process != -1) {
2726 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002727 " - <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 +01002728 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002729 __FUNCTION__, s, group->id, s->uniq_id, ctx->status_code,
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002730 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002731 ctx->stats.t_response, ctx->stats.t_process,
2732 agent->counters.idles, agent->counters.applets,
2733 agent->counters.nb_sending, agent->counters.nb_waiting,
2734 agent->counters.nb_errors, agent->counters.nb_processed,
2735 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2736 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2737 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2738 "SPOE: [%s] <GROUP:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2739 agent->id, group->id, s->uniq_id, ctx->status_code,
2740 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2741 ctx->stats.t_response, ctx->stats.t_process,
2742 agent->counters.idles, agent->counters.applets,
2743 agent->counters.nb_sending, agent->counters.nb_waiting,
2744 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002745 }
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002746 return ret;
2747}
2748
Christopher Faulet58d03682017-09-21 16:57:24 +02002749/* Process a SPOE event, ie the list of messages attached to the event <ev>.
2750 * See spoe_process_message for details. */
2751static int
2752spoe_process_event(struct stream *s, struct spoe_context *ctx,
2753 enum spoe_event ev)
2754{
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002755 struct spoe_config *conf = FLT_CONF(ctx->filter);
2756 struct spoe_agent *agent = conf->agent;
Christopher Faulet58d03682017-09-21 16:57:24 +02002757 int dir, ret;
2758
2759 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Faulet344c4ab2017-09-22 10:20:13 +02002760 " - ctx-state=%s - Process messages for event=%s\n",
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002761 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Faulet58d03682017-09-21 16:57:24 +02002762 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
2763 spoe_event_str[ev]);
2764
2765 dir = ((ev < SPOE_EV_ON_SERVER_SESS) ? SMP_OPT_DIR_REQ : SMP_OPT_DIR_RES);
2766
2767 if (LIST_ISEMPTY(&(ctx->events[ev])))
2768 return 1;
2769
2770 ret = spoe_process_messages(s, ctx, &(ctx->events[ev]), dir, SPOE_MSGS_BY_EVENT);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002771 if (ret && ctx->stats.t_process != -1) {
2772 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002773 " - <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 +01002774 (int)now.tv_sec, (int)now.tv_usec, agent->id,
2775 __FUNCTION__, s, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2776 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02002777 ctx->stats.t_response, ctx->stats.t_process,
2778 agent->counters.idles, agent->counters.applets,
2779 agent->counters.nb_sending, agent->counters.nb_waiting,
2780 agent->counters.nb_errors, agent->counters.nb_processed,
2781 agent->rt[tid].processing, read_freq_ctr(&agent->rt[tid].processing_per_sec));
2782 if (ctx->status_code || !(conf->agent_fe.options2 & PR_O2_NOLOGNORM))
2783 send_log(&conf->agent_fe, (!ctx->status_code ? LOG_NOTICE : LOG_WARNING),
2784 "SPOE: [%s] <EVENT:%s> sid=%u st=%u %ld/%ld/%ld/%ld/%ld %u/%u %u/%u %llu/%llu\n",
2785 agent->id, spoe_event_str[ev], s->uniq_id, ctx->status_code,
2786 ctx->stats.t_request, ctx->stats.t_queue, ctx->stats.t_waiting,
2787 ctx->stats.t_response, ctx->stats.t_process,
2788 agent->counters.idles, agent->counters.applets,
2789 agent->counters.nb_sending, agent->counters.nb_waiting,
2790 agent->counters.nb_errors, agent->counters.nb_processed);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002791 }
Christopher Fauleta1cda022016-12-21 08:58:06 +01002792 return ret;
2793}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002794
2795/***************************************************************************
2796 * Functions that create/destroy SPOE contexts
2797 **************************************************************************/
Christopher Fauleta1cda022016-12-21 08:58:06 +01002798static int
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002799spoe_acquire_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002800{
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002801 if (buf->size)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002802 return 1;
2803
Willy Tarreau21046592020-02-26 10:39:36 +01002804 if (MT_LIST_ADDED(&buffer_wait->list))
2805 MT_LIST_DEL(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002806
Christopher Faulet4596fb72017-01-11 14:05:19 +01002807 if (b_alloc_margin(buf, global.tune.reserved_bufs))
Christopher Fauleta1cda022016-12-21 08:58:06 +01002808 return 1;
2809
Willy Tarreau21046592020-02-26 10:39:36 +01002810 MT_LIST_ADDQ(&buffer_wq, &buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002811 return 0;
2812}
2813
2814static void
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002815spoe_release_buffer(struct buffer *buf, struct buffer_wait *buffer_wait)
Christopher Fauleta1cda022016-12-21 08:58:06 +01002816{
Willy Tarreau21046592020-02-26 10:39:36 +01002817 if (MT_LIST_ADDED(&buffer_wait->list))
2818 MT_LIST_DEL(&buffer_wait->list);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002819
2820 /* Release the buffer if needed */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002821 if (buf->size) {
Christopher Faulet4596fb72017-01-11 14:05:19 +01002822 b_free(buf);
Olivier Houchard673867c2018-05-25 16:58:52 +02002823 offer_buffers(buffer_wait->target, tasks_run_queue);
Christopher Fauleta1cda022016-12-21 08:58:06 +01002824 }
2825}
2826
Christopher Faulet4596fb72017-01-11 14:05:19 +01002827static int
Christopher Faulet8ef75252017-02-20 22:56:03 +01002828spoe_wakeup_context(struct spoe_context *ctx)
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002829{
2830 task_wakeup(ctx->strm->task, TASK_WOKEN_MSG);
2831 return 1;
2832}
2833
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002834static struct spoe_context *
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002835spoe_create_context(struct stream *s, struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002836{
2837 struct spoe_config *conf = FLT_CONF(filter);
2838 struct spoe_context *ctx;
2839
Willy Tarreaubafbe012017-11-24 17:34:44 +01002840 ctx = pool_alloc_dirty(pool_head_spoe_ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002841 if (ctx == NULL) {
2842 return NULL;
2843 }
2844 memset(ctx, 0, sizeof(*ctx));
Christopher Fauletb067b062017-01-04 16:39:11 +01002845 ctx->filter = filter;
2846 ctx->state = SPOE_CTX_ST_NONE;
2847 ctx->status_code = SPOE_CTX_ERR_NONE;
2848 ctx->flags = 0;
Christopher Faulet11610f32017-09-21 10:23:10 +02002849 ctx->events = conf->agent->events;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02002850 ctx->groups = &conf->agent->groups;
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002851 ctx->buffer = BUF_NULL;
Willy Tarreau21046592020-02-26 10:39:36 +01002852 MT_LIST_INIT(&ctx->buffer_wait.list);
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002853 ctx->buffer_wait.target = ctx;
Christopher Faulet8ef75252017-02-20 22:56:03 +01002854 ctx->buffer_wait.wakeup_cb = (int (*)(void *))spoe_wakeup_context;
Christopher Fauleta1cda022016-12-21 08:58:06 +01002855 LIST_INIT(&ctx->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002856
Christopher Fauletf7a30922016-11-10 15:04:51 +01002857 ctx->stream_id = 0;
2858 ctx->frame_id = 1;
2859 ctx->process_exp = TICK_ETERNITY;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002860
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002861 tv_zero(&ctx->stats.tv_start);
2862 tv_zero(&ctx->stats.tv_request);
2863 tv_zero(&ctx->stats.tv_queue);
2864 tv_zero(&ctx->stats.tv_wait);
2865 tv_zero(&ctx->stats.tv_response);
2866 ctx->stats.t_request = -1;
2867 ctx->stats.t_queue = -1;
2868 ctx->stats.t_waiting = -1;
2869 ctx->stats.t_response = -1;
2870 ctx->stats.t_process = -1;
2871 ctx->stats.t_total = 0;
2872
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002873 ctx->strm = s;
2874 ctx->state = SPOE_CTX_ST_READY;
2875 filter->ctx = ctx;
2876
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002877 return ctx;
2878}
2879
2880static void
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002881spoe_destroy_context(struct filter *filter)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002882{
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002883 struct spoe_config *conf = FLT_CONF(filter);
2884 struct spoe_context *ctx = filter->ctx;
2885
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002886 if (!ctx)
2887 return;
2888
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002889 spoe_stop_processing(conf->agent, ctx);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002890 pool_free(pool_head_spoe_ctx, ctx);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01002891 filter->ctx = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002892}
2893
2894static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002895spoe_reset_context(struct spoe_context *ctx)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002896{
2897 ctx->state = SPOE_CTX_ST_READY;
Christopher Fauletf032c3e2017-02-17 15:18:35 +01002898 ctx->flags &= ~(SPOE_CTX_FL_PROCESS|SPOE_CTX_FL_FRAGMENTED);
Christopher Fauletb2dd1e02018-03-22 09:07:41 +01002899
2900 tv_zero(&ctx->stats.tv_start);
2901 tv_zero(&ctx->stats.tv_request);
2902 tv_zero(&ctx->stats.tv_queue);
2903 tv_zero(&ctx->stats.tv_wait);
2904 tv_zero(&ctx->stats.tv_response);
2905 ctx->stats.t_request = -1;
2906 ctx->stats.t_queue = -1;
2907 ctx->stats.t_waiting = -1;
2908 ctx->stats.t_response = -1;
2909 ctx->stats.t_process = -1;
2910 ctx->stats.t_total = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002911}
2912
2913
2914/***************************************************************************
2915 * Hooks that manage the filter lifecycle (init/check/deinit)
2916 **************************************************************************/
2917/* Signal handler: Do a soft stop, wakeup SPOE applet */
2918static void
Christopher Faulet8ef75252017-02-20 22:56:03 +01002919spoe_sig_stop(struct sig_handler *sh)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002920{
2921 struct proxy *p;
2922
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002923 p = proxies_list;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002924 while (p) {
2925 struct flt_conf *fconf;
2926
2927 list_for_each_entry(fconf, &p->filter_configs, list) {
Christopher Faulet3b386a32017-02-23 10:17:15 +01002928 struct spoe_config *conf;
2929 struct spoe_agent *agent;
Christopher Faulet42bfa462017-01-04 14:14:19 +01002930 struct spoe_appctx *spoe_appctx;
Christopher Faulet24289f22017-09-25 14:48:02 +02002931 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002932
Christopher Faulet3b386a32017-02-23 10:17:15 +01002933 if (fconf->id != spoe_filter_id)
2934 continue;
2935
2936 conf = fconf->conf;
2937 agent = conf->agent;
2938
Christopher Faulet24289f22017-09-25 14:48:02 +02002939 for (i = 0; i < global.nbthread; ++i) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002940 HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Faulet24289f22017-09-25 14:48:02 +02002941 list_for_each_entry(spoe_appctx, &agent->rt[i].applets, list)
2942 spoe_wakeup_appctx(spoe_appctx->owner);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002943 HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002944 }
2945 }
2946 p = p->next;
2947 }
2948}
2949
2950
2951/* Initialize the SPOE filter. Returns -1 on error, else 0. */
2952static int
2953spoe_init(struct proxy *px, struct flt_conf *fconf)
2954{
2955 struct spoe_config *conf = fconf->conf;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002956
Christopher Faulet7250b8f2018-03-26 17:19:01 +02002957 /* conf->agent_fe was already initialized during the config
2958 * parsing. Finish initialization. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002959 conf->agent_fe.last_change = now.tv_sec;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002960 conf->agent_fe.cap = PR_CAP_FE;
2961 conf->agent_fe.mode = PR_MODE_TCP;
2962 conf->agent_fe.maxconn = 0;
2963 conf->agent_fe.options2 |= PR_O2_INDEPSTR;
2964 conf->agent_fe.conn_retries = CONN_RETRIES;
2965 conf->agent_fe.accept = frontend_accept;
2966 conf->agent_fe.srv = NULL;
2967 conf->agent_fe.timeout.client = TICK_ETERNITY;
2968 conf->agent_fe.default_target = &spoe_applet.obj_type;
2969 conf->agent_fe.fe_req_ana = AN_REQ_SWITCHING_RULES;
2970
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002971 if (!sighandler_registered) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01002972 signal_register_fct(0, spoe_sig_stop, 0);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002973 sighandler_registered = 1;
2974 }
2975
Christopher Faulet00292352019-01-09 15:05:10 +01002976 fconf->flags |= FLT_CFG_FL_HTX;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002977 return 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002978}
2979
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05002980/* Free resources allocated by the SPOE filter. */
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002981static void
2982spoe_deinit(struct proxy *px, struct flt_conf *fconf)
2983{
2984 struct spoe_config *conf = fconf->conf;
2985
2986 if (conf) {
2987 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002988
Christopher Faulet8ef75252017-02-20 22:56:03 +01002989 spoe_release_agent(agent);
Christopher Faulet7ee86672017-09-19 11:08:28 +02002990 free(conf->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02002991 free(conf);
2992 }
2993 fconf->conf = NULL;
2994}
2995
2996/* Check configuration of a SPOE filter for a specified proxy.
2997 * Return 1 on error, else 0. */
2998static int
2999spoe_check(struct proxy *px, struct flt_conf *fconf)
3000{
Christopher Faulet7ee86672017-09-19 11:08:28 +02003001 struct flt_conf *f;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003002 struct spoe_config *conf = fconf->conf;
3003 struct proxy *target;
Willy Tarreaub0769b22019-02-07 13:40:33 +01003004 int i;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003005
Christopher Faulet7ee86672017-09-19 11:08:28 +02003006 /* Check all SPOE filters for proxy <px> to be sure all SPOE agent names
3007 * are uniq */
3008 list_for_each_entry(f, &px->filter_configs, list) {
3009 struct spoe_config *c = f->conf;
3010
3011 /* This is not an SPOE filter */
3012 if (f->id != spoe_filter_id)
3013 continue;
3014 /* This is the current SPOE filter */
3015 if (f == fconf)
3016 continue;
3017
3018 /* Check engine Id. It should be uniq */
3019 if (!strcmp(conf->id, c->id)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003020 ha_alert("Proxy %s : duplicated name for SPOE engine '%s'.\n",
3021 px->id, conf->id);
Christopher Faulet7ee86672017-09-19 11:08:28 +02003022 return 1;
3023 }
3024 }
3025
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003026 target = proxy_be_by_name(conf->agent->b.name);
3027 if (target == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003028 ha_alert("Proxy %s : unknown backend '%s' used by SPOE agent '%s'"
3029 " declared at %s:%d.\n",
3030 px->id, conf->agent->b.name, conf->agent->id,
3031 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003032 return 1;
3033 }
3034 if (target->mode != PR_MODE_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003035 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3036 " at %s:%d does not support HTTP mode.\n",
3037 px->id, target->id, conf->agent->id,
3038 conf->agent->conf.file, conf->agent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003039 return 1;
3040 }
3041
Willy Tarreau2bdcfde2019-02-05 13:37:19 +01003042 if (px->bind_proc & ~target->bind_proc) {
3043 ha_alert("Proxy %s : backend '%s' used by SPOE agent '%s' declared"
3044 " at %s:%d does not cover all of its processes.\n",
3045 px->id, target->id, conf->agent->id,
3046 conf->agent->conf.file, conf->agent->conf.line);
3047 return 1;
3048 }
3049
Christopher Fauletfe261552019-03-18 13:57:42 +01003050 if ((conf->agent->rt = calloc(global.nbthread, sizeof(*conf->agent->rt))) == NULL) {
Willy Tarreaub0769b22019-02-07 13:40:33 +01003051 ha_alert("Proxy %s : out of memory initializing SPOE agent '%s' declared at %s:%d.\n",
3052 px->id, conf->agent->id, conf->agent->conf.file, conf->agent->conf.line);
3053 return 1;
3054 }
3055 for (i = 0; i < global.nbthread; ++i) {
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003056 conf->agent->rt[i].engine_id = NULL;
Christopher Fauletfe261552019-03-18 13:57:42 +01003057 conf->agent->rt[i].frame_size = conf->agent->max_frame_size;
3058 conf->agent->rt[i].processing = 0;
3059 LIST_INIT(&conf->agent->rt[i].applets);
3060 LIST_INIT(&conf->agent->rt[i].sending_queue);
3061 LIST_INIT(&conf->agent->rt[i].waiting_queue);
3062 HA_SPIN_INIT(&conf->agent->rt[i].lock);
Willy Tarreaub0769b22019-02-07 13:40:33 +01003063 }
3064
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003065 free(conf->agent->b.name);
3066 conf->agent->b.name = NULL;
3067 conf->agent->b.be = target;
3068 return 0;
3069}
3070
Kevin Zhud87b1a52019-09-17 15:05:45 +02003071/* Initializes the SPOE filter for a proxy for a specific thread.
3072 * Returns a negative value if an error occurs. */
3073static int
3074spoe_init_per_thread(struct proxy *p, struct flt_conf *fconf)
3075{
3076 struct spoe_config *conf = fconf->conf;
3077 struct spoe_agent *agent = conf->agent;
3078
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003079 agent->rt[tid].engine_id = generate_pseudo_uuid();
3080 if (agent->rt[tid].engine_id == NULL)
3081 return -1;
Kevin Zhud87b1a52019-09-17 15:05:45 +02003082 return 0;
3083}
3084
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003085/**************************************************************************
3086 * Hooks attached to a stream
3087 *************************************************************************/
3088/* Called when a filter instance is created and attach to a stream. It creates
3089 * the context that will be used to process this stream. */
3090static int
3091spoe_start(struct stream *s, struct filter *filter)
3092{
Christopher Faulet72bcc472017-01-04 16:39:41 +01003093 struct spoe_config *conf = FLT_CONF(filter);
3094 struct spoe_agent *agent = conf->agent;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003095 struct spoe_context *ctx;
3096
3097 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
Christopher Faulet72bcc472017-01-04 16:39:41 +01003098 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003099 __FUNCTION__, s);
3100
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003101 if ((ctx = spoe_create_context(s, filter)) == NULL) {
Christopher Faulet72bcc472017-01-04 16:39:41 +01003102 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
3103 " - failed to create SPOE context\n",
3104 (int)now.tv_sec, (int)now.tv_usec, agent->id,
Christopher Fauletccbc3fd2017-09-15 11:51:18 +02003105 __FUNCTION__, s);
Christopher Faulet3b8e3492018-03-26 17:20:58 +02003106 send_log(&conf->agent_fe, LOG_EMERG,
Christopher Faulet72bcc472017-01-04 16:39:41 +01003107 "SPOE: [%s] failed to create SPOE context\n",
3108 agent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003109 return 0;
3110 }
3111
Christopher Faulet11610f32017-09-21 10:23:10 +02003112 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003113 filter->pre_analyzers |= AN_REQ_INSPECT_FE;
3114
Christopher Faulet11610f32017-09-21 10:23:10 +02003115 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003116 filter->pre_analyzers |= AN_REQ_INSPECT_BE;
3117
Christopher Faulet11610f32017-09-21 10:23:10 +02003118 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_TCP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003119 filter->pre_analyzers |= AN_RES_INSPECT;
3120
Christopher Faulet11610f32017-09-21 10:23:10 +02003121 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_FE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003122 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_FE;
3123
Christopher Faulet11610f32017-09-21 10:23:10 +02003124 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_REQ_BE]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003125 filter->pre_analyzers |= AN_REQ_HTTP_PROCESS_BE;
3126
Christopher Faulet11610f32017-09-21 10:23:10 +02003127 if (!LIST_ISEMPTY(&ctx->events[SPOE_EV_ON_HTTP_RSP]))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003128 filter->pre_analyzers |= AN_RES_HTTP_PROCESS_FE;
3129
3130 return 1;
3131}
3132
3133/* Called when a filter instance is detached from a stream. It release the
3134 * attached SPOE context. */
3135static void
3136spoe_stop(struct stream *s, struct filter *filter)
3137{
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003138 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p\n",
3139 (int)now.tv_sec, (int)now.tv_usec,
3140 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3141 __FUNCTION__, s);
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01003142 spoe_destroy_context(filter);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003143}
3144
Christopher Fauletf7a30922016-11-10 15:04:51 +01003145
3146/*
3147 * Called when the stream is woken up because of expired timer.
3148 */
3149static void
3150spoe_check_timeouts(struct stream *s, struct filter *filter)
3151{
3152 struct spoe_context *ctx = filter->ctx;
3153
Christopher Fauletac580602018-03-20 16:09:20 +01003154 if (tick_is_expired(ctx->process_exp, now_ms))
Christopher Fauleta73e59b2016-12-09 17:30:18 +01003155 s->pending_events |= TASK_WOKEN_MSG;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003156}
3157
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003158/* Called when we are ready to filter data on a channel */
3159static int
3160spoe_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3161{
3162 struct spoe_context *ctx = filter->ctx;
3163 int ret = 1;
3164
3165 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3166 " - ctx-flags=0x%08x\n",
3167 (int)now.tv_sec, (int)now.tv_usec,
3168 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3169 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3170
Christopher Fauletb067b062017-01-04 16:39:11 +01003171 if (ctx->state == SPOE_CTX_ST_NONE)
3172 goto out;
3173
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003174 if (!(chn->flags & CF_ISRESP)) {
3175 if (filter->pre_analyzers & AN_REQ_INSPECT_FE)
3176 chn->analysers |= AN_REQ_INSPECT_FE;
3177 if (filter->pre_analyzers & AN_REQ_INSPECT_BE)
3178 chn->analysers |= AN_REQ_INSPECT_BE;
3179
3180 if (ctx->flags & SPOE_CTX_FL_CLI_CONNECTED)
3181 goto out;
3182
3183 ctx->stream_id = s->uniq_id;
Christopher Faulet8ef75252017-02-20 22:56:03 +01003184 ret = spoe_process_event(s, ctx, SPOE_EV_ON_CLIENT_SESS);
Christopher Fauletb067b062017-01-04 16:39:11 +01003185 if (!ret)
3186 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003187 ctx->flags |= SPOE_CTX_FL_CLI_CONNECTED;
3188 }
3189 else {
Miroslav Zagorac88403262020-06-19 22:17:17 +02003190 if (filter->pre_analyzers & AN_RES_INSPECT)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003191 chn->analysers |= AN_RES_INSPECT;
3192
3193 if (ctx->flags & SPOE_CTX_FL_SRV_CONNECTED)
3194 goto out;
3195
Christopher Faulet8ef75252017-02-20 22:56:03 +01003196 ret = spoe_process_event(s, ctx, SPOE_EV_ON_SERVER_SESS);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003197 if (!ret) {
3198 channel_dont_read(chn);
3199 channel_dont_close(chn);
Christopher Fauletb067b062017-01-04 16:39:11 +01003200 goto out;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003201 }
Christopher Fauletb067b062017-01-04 16:39:11 +01003202 ctx->flags |= SPOE_CTX_FL_SRV_CONNECTED;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003203 }
3204
3205 out:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003206 return ret;
3207}
3208
3209/* Called before a processing happens on a given channel */
3210static int
3211spoe_chn_pre_analyze(struct stream *s, struct filter *filter,
3212 struct channel *chn, unsigned an_bit)
3213{
3214 struct spoe_context *ctx = filter->ctx;
3215 int ret = 1;
3216
3217 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3218 " - ctx-flags=0x%08x - ana=0x%08x\n",
3219 (int)now.tv_sec, (int)now.tv_usec,
3220 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3221 __FUNCTION__, s, spoe_ctx_state_str[ctx->state],
3222 ctx->flags, an_bit);
3223
Christopher Fauletb067b062017-01-04 16:39:11 +01003224 if (ctx->state == SPOE_CTX_ST_NONE)
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003225 goto out;
3226
3227 switch (an_bit) {
3228 case AN_REQ_INSPECT_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003229 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003230 break;
3231 case AN_REQ_INSPECT_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003232 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003233 break;
3234 case AN_RES_INSPECT:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003235 ret = spoe_process_event(s, ctx, SPOE_EV_ON_TCP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003236 break;
3237 case AN_REQ_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003238 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_FE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003239 break;
3240 case AN_REQ_HTTP_PROCESS_BE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003241 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_REQ_BE);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003242 break;
3243 case AN_RES_HTTP_PROCESS_FE:
Christopher Faulet8ef75252017-02-20 22:56:03 +01003244 ret = spoe_process_event(s, ctx, SPOE_EV_ON_HTTP_RSP);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003245 break;
3246 }
3247
3248 out:
Christopher Faulet9cdca972018-02-01 08:45:45 +01003249 if (!ret && (chn->flags & CF_ISRESP)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003250 channel_dont_read(chn);
3251 channel_dont_close(chn);
3252 }
3253 return ret;
3254}
3255
3256/* Called when the filtering on the channel ends. */
3257static int
3258spoe_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
3259{
3260 struct spoe_context *ctx = filter->ctx;
3261
3262 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p - ctx-state=%s"
3263 " - ctx-flags=0x%08x\n",
3264 (int)now.tv_sec, (int)now.tv_usec,
3265 ((struct spoe_config *)FLT_CONF(filter))->agent->id,
3266 __FUNCTION__, s, spoe_ctx_state_str[ctx->state], ctx->flags);
3267
3268 if (!(ctx->flags & SPOE_CTX_FL_PROCESS)) {
Christopher Faulet8ef75252017-02-20 22:56:03 +01003269 spoe_reset_context(ctx);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003270 }
3271
3272 return 1;
3273}
3274
3275/********************************************************************
3276 * Functions that manage the filter initialization
3277 ********************************************************************/
3278struct flt_ops spoe_ops = {
3279 /* Manage SPOE filter, called for each filter declaration */
3280 .init = spoe_init,
3281 .deinit = spoe_deinit,
3282 .check = spoe_check,
Kevin Zhud87b1a52019-09-17 15:05:45 +02003283 .init_per_thread = spoe_init_per_thread,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003284
3285 /* Handle start/stop of SPOE */
Christopher Fauletf7a30922016-11-10 15:04:51 +01003286 .attach = spoe_start,
3287 .detach = spoe_stop,
3288 .check_timeouts = spoe_check_timeouts,
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003289
3290 /* Handle channels activity */
3291 .channel_start_analyze = spoe_start_analyze,
3292 .channel_pre_analyze = spoe_chn_pre_analyze,
3293 .channel_end_analyze = spoe_end_analyze,
3294};
3295
3296
3297static int
3298cfg_parse_spoe_agent(const char *file, int linenum, char **args, int kwm)
3299{
3300 const char *err;
3301 int i, err_code = 0;
3302
3303 if ((cfg_scope == NULL && curengine != NULL) ||
3304 (cfg_scope != NULL && curengine == NULL) ||
Christopher Faulete1405e52017-09-19 10:35:35 +02003305 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003306 goto out;
3307
3308 if (!strcmp(args[0], "spoe-agent")) { /* new spoe-agent section */
3309 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003310 ha_alert("parsing [%s:%d] : missing name for spoe-agent section.\n",
3311 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003312 err_code |= ERR_ALERT | ERR_ABORT;
3313 goto out;
3314 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003315 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3316 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003317 goto out;
3318 }
3319
3320 err = invalid_char(args[1]);
3321 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003322 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3323 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003324 err_code |= ERR_ALERT | ERR_ABORT;
3325 goto out;
3326 }
3327
3328 if (curagent != NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003329 ha_alert("parsing [%s:%d] : another spoe-agent section previously defined.\n",
3330 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003331 err_code |= ERR_ALERT | ERR_ABORT;
3332 goto out;
3333 }
3334 if ((curagent = calloc(1, sizeof(*curagent))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003335 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003336 err_code |= ERR_ALERT | ERR_ABORT;
3337 goto out;
3338 }
3339
3340 curagent->id = strdup(args[1]);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003341
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003342 curagent->conf.file = strdup(file);
3343 curagent->conf.line = linenum;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003344
3345 curagent->timeout.hello = TICK_ETERNITY;
3346 curagent->timeout.idle = TICK_ETERNITY;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003347 curagent->timeout.processing = TICK_ETERNITY;
Christopher Fauleta1cda022016-12-21 08:58:06 +01003348
Christopher Fauleta1cda022016-12-21 08:58:06 +01003349 curagent->var_pfx = NULL;
3350 curagent->var_on_error = NULL;
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003351 curagent->var_t_process = NULL;
3352 curagent->var_t_total = NULL;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003353 curagent->flags = (SPOE_FL_ASYNC | SPOE_FL_PIPELINING | SPOE_FL_SND_FRAGMENTATION);
Christopher Fauleta1cda022016-12-21 08:58:06 +01003354 curagent->cps_max = 0;
3355 curagent->eps_max = 0;
Christopher Faulet7aa0b2b2017-01-13 11:30:50 +01003356 curagent->max_frame_size = MAX_FRAME_SIZE;
Christopher Fauletb077cdc2018-01-24 16:37:57 +01003357 curagent->max_fpa = 20;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003358
3359 for (i = 0; i < SPOE_EV_EVENTS; ++i)
Christopher Faulet11610f32017-09-21 10:23:10 +02003360 LIST_INIT(&curagent->events[i]);
3361 LIST_INIT(&curagent->groups);
3362 LIST_INIT(&curagent->messages);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003363 }
3364 else if (!strcmp(args[0], "use-backend")) {
3365 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003366 ha_alert("parsing [%s:%d] : '%s' expects a backend name.\n",
3367 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003368 err_code |= ERR_ALERT | ERR_FATAL;
3369 goto out;
3370 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003371 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003372 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003373 free(curagent->b.name);
3374 curagent->b.name = strdup(args[1]);
3375 }
3376 else if (!strcmp(args[0], "messages")) {
3377 int cur_arg = 1;
3378 while (*args[cur_arg]) {
Christopher Faulet11610f32017-09-21 10:23:10 +02003379 struct spoe_placeholder *ph = NULL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003380
Christopher Faulet11610f32017-09-21 10:23:10 +02003381 list_for_each_entry(ph, &curmphs, list) {
3382 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003383 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3384 file, linenum, args[cur_arg]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003385 err_code |= ERR_ALERT | ERR_FATAL;
3386 goto out;
3387 }
3388 }
3389
Christopher Faulet11610f32017-09-21 10:23:10 +02003390 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003391 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003392 err_code |= ERR_ALERT | ERR_ABORT;
3393 goto out;
3394 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003395 ph->id = strdup(args[cur_arg]);
3396 LIST_ADDQ(&curmphs, &ph->list);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003397 cur_arg++;
3398 }
3399 }
Christopher Faulet11610f32017-09-21 10:23:10 +02003400 else if (!strcmp(args[0], "groups")) {
3401 int cur_arg = 1;
3402 while (*args[cur_arg]) {
3403 struct spoe_placeholder *ph = NULL;
3404
3405 list_for_each_entry(ph, &curgphs, list) {
3406 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003407 ha_alert("parsing [%s:%d]: spoe-group '%s' already used.\n",
3408 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003409 err_code |= ERR_ALERT | ERR_FATAL;
3410 goto out;
3411 }
3412 }
3413
3414 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003415 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003416 err_code |= ERR_ALERT | ERR_ABORT;
3417 goto out;
3418 }
3419 ph->id = strdup(args[cur_arg]);
3420 LIST_ADDQ(&curgphs, &ph->list);
3421 cur_arg++;
3422 }
3423 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003424 else if (!strcmp(args[0], "timeout")) {
3425 unsigned int *tv = NULL;
3426 const char *res;
3427 unsigned timeout;
3428
3429 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003430 ha_alert("parsing [%s:%d] : 'timeout' expects 'hello', 'idle' and 'processing'.\n",
3431 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003432 err_code |= ERR_ALERT | ERR_FATAL;
3433 goto out;
3434 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003435 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3436 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003437 if (!strcmp(args[1], "hello"))
3438 tv = &curagent->timeout.hello;
3439 else if (!strcmp(args[1], "idle"))
3440 tv = &curagent->timeout.idle;
Christopher Fauletf7a30922016-11-10 15:04:51 +01003441 else if (!strcmp(args[1], "processing"))
3442 tv = &curagent->timeout.processing;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003443 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003444 ha_alert("parsing [%s:%d] : 'timeout' supports 'hello', 'idle' or 'processing' (got %s).\n",
3445 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003446 err_code |= ERR_ALERT | ERR_FATAL;
3447 goto out;
3448 }
3449 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003450 ha_alert("parsing [%s:%d] : 'timeout %s' expects an integer value (in milliseconds).\n",
3451 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003452 err_code |= ERR_ALERT | ERR_FATAL;
3453 goto out;
3454 }
3455 res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02003456 if (res == PARSE_TIME_OVER) {
3457 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
3458 file, linenum, args[2], args[0], args[1]);
3459 err_code |= ERR_ALERT | ERR_FATAL;
3460 goto out;
3461 }
3462 else if (res == PARSE_TIME_UNDER) {
3463 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
3464 file, linenum, args[2], args[0], args[1]);
3465 err_code |= ERR_ALERT | ERR_FATAL;
3466 goto out;
3467 }
3468 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003469 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'timeout %s'.\n",
3470 file, linenum, *res, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003471 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003472 goto out;
3473 }
3474 *tv = MS_TO_TICKS(timeout);
3475 }
3476 else if (!strcmp(args[0], "option")) {
3477 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003478 ha_alert("parsing [%s:%d]: '%s' expects an option name.\n",
3479 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003480 err_code |= ERR_ALERT | ERR_FATAL;
3481 goto out;
3482 }
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003483
Christopher Faulet305c6072017-02-23 16:17:53 +01003484 if (!strcmp(args[1], "pipelining")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003485 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003486 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003487 if (kwm == 1)
3488 curagent->flags &= ~SPOE_FL_PIPELINING;
3489 else
3490 curagent->flags |= SPOE_FL_PIPELINING;
3491 goto out;
3492 }
3493 else if (!strcmp(args[1], "async")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003494 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet305c6072017-02-23 16:17:53 +01003495 goto out;
Christopher Faulet305c6072017-02-23 16:17:53 +01003496 if (kwm == 1)
3497 curagent->flags &= ~SPOE_FL_ASYNC;
Christopher Fauletb1bb1af2019-09-17 11:55:52 +02003498 else
3499 curagent->flags |= SPOE_FL_ASYNC;
Christopher Faulet305c6072017-02-23 16:17:53 +01003500 goto out;
3501 }
Christopher Fauletcecd8522017-02-24 22:11:21 +01003502 else if (!strcmp(args[1], "send-frag-payload")) {
3503 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3504 goto out;
3505 if (kwm == 1)
3506 curagent->flags &= ~SPOE_FL_SND_FRAGMENTATION;
3507 else
3508 curagent->flags |= SPOE_FL_SND_FRAGMENTATION;
3509 goto out;
3510 }
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003511 else if (!strcmp(args[1], "dontlog-normal")) {
3512 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3513 goto out;
3514 if (kwm == 1)
3515 curpxopts2 &= ~PR_O2_NOLOGNORM;
3516 else
3517 curpxopts2 |= PR_O2_NOLOGNORM;
Christopher Faulet799f5182018-04-26 11:36:34 +02003518 goto out;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02003519 }
Christopher Faulet305c6072017-02-23 16:17:53 +01003520
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003521 /* Following options does not support negation */
3522 if (kwm == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003523 ha_alert("parsing [%s:%d]: negation is not supported for option '%s'.\n",
3524 file, linenum, args[1]);
Christopher Faulet6a2940c2017-02-23 15:06:26 +01003525 err_code |= ERR_ALERT | ERR_FATAL;
3526 goto out;
3527 }
3528
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003529 if (!strcmp(args[1], "var-prefix")) {
3530 char *tmp;
3531
3532 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003533 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3534 file, linenum, args[0],
3535 args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003536 err_code |= ERR_ALERT | ERR_FATAL;
3537 goto out;
3538 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003539 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3540 goto out;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003541 tmp = args[2];
3542 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003543 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003544 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003545 file, linenum, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003546 err_code |= ERR_ALERT | ERR_FATAL;
3547 goto out;
3548 }
3549 tmp++;
3550 }
3551 curagent->var_pfx = strdup(args[2]);
3552 }
Etienne Carriereaec89892017-12-14 09:36:40 +00003553 else if (!strcmp(args[1], "force-set-var")) {
3554 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3555 goto out;
3556 curagent->flags |= SPOE_FL_FORCE_SET_VAR;
3557 }
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003558 else if (!strcmp(args[1], "continue-on-error")) {
Christopher Fauletecc537a2017-02-23 22:52:39 +01003559 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003560 goto out;
Christopher Fauletea62c2a2016-11-14 10:54:21 +01003561 curagent->flags |= SPOE_FL_CONT_ON_ERR;
3562 }
Christopher Faulet985532d2016-11-16 15:36:19 +01003563 else if (!strcmp(args[1], "set-on-error")) {
3564 char *tmp;
3565
3566 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003567 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3568 file, linenum, args[0],
3569 args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003570 err_code |= ERR_ALERT | ERR_FATAL;
3571 goto out;
3572 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003573 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3574 goto out;
Christopher Faulet985532d2016-11-16 15:36:19 +01003575 tmp = args[2];
3576 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003577 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003578 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003579 file, linenum, args[0], args[1]);
Christopher Faulet985532d2016-11-16 15:36:19 +01003580 err_code |= ERR_ALERT | ERR_FATAL;
3581 goto out;
3582 }
3583 tmp++;
3584 }
3585 curagent->var_on_error = strdup(args[2]);
3586 }
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003587 else if (!strcmp(args[1], "set-process-time")) {
3588 char *tmp;
3589
3590 if (!*args[2]) {
3591 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3592 file, linenum, args[0],
3593 args[1]);
3594 err_code |= ERR_ALERT | ERR_FATAL;
3595 goto out;
3596 }
3597 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3598 goto out;
3599 tmp = args[2];
3600 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003601 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003602 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003603 file, linenum, args[0], args[1]);
3604 err_code |= ERR_ALERT | ERR_FATAL;
3605 goto out;
3606 }
3607 tmp++;
3608 }
3609 curagent->var_t_process = strdup(args[2]);
3610 }
3611 else if (!strcmp(args[1], "set-total-time")) {
3612 char *tmp;
3613
3614 if (!*args[2]) {
3615 ha_alert("parsing [%s:%d]: '%s %s' expects a value.\n",
3616 file, linenum, args[0],
3617 args[1]);
3618 err_code |= ERR_ALERT | ERR_FATAL;
3619 goto out;
3620 }
3621 if (alertif_too_many_args(2, file, linenum, args, &err_code))
3622 goto out;
3623 tmp = args[2];
3624 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01003625 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER01a3f202018-05-10 16:41:26 +02003626 ha_alert("parsing [%s:%d]: '%s %s' only supports [a-zA-Z0-9_.] chars.\n",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01003627 file, linenum, args[0], args[1]);
3628 err_code |= ERR_ALERT | ERR_FATAL;
3629 goto out;
3630 }
3631 tmp++;
3632 }
3633 curagent->var_t_total = strdup(args[2]);
3634 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003635 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003636 ha_alert("parsing [%s:%d]: option '%s' is not supported.\n",
3637 file, linenum, args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003638 err_code |= ERR_ALERT | ERR_FATAL;
3639 goto out;
3640 }
Christopher Faulet48026722016-11-16 15:01:12 +01003641 }
3642 else if (!strcmp(args[0], "maxconnrate")) {
3643 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003644 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3645 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003646 err_code |= ERR_ALERT | ERR_FATAL;
3647 goto out;
3648 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003649 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003650 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003651 curagent->cps_max = atol(args[1]);
3652 }
3653 else if (!strcmp(args[0], "maxerrrate")) {
3654 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003655 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3656 file, linenum, args[0]);
Christopher Faulet48026722016-11-16 15:01:12 +01003657 err_code |= ERR_ALERT | ERR_FATAL;
3658 goto out;
3659 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003660 if (alertif_too_many_args(1, file, linenum, args, &err_code))
Christopher Faulet48026722016-11-16 15:01:12 +01003661 goto out;
Christopher Faulet48026722016-11-16 15:01:12 +01003662 curagent->eps_max = atol(args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003663 }
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003664 else if (!strcmp(args[0], "max-frame-size")) {
3665 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003666 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3667 file, linenum, args[0]);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003668 err_code |= ERR_ALERT | ERR_FATAL;
3669 goto out;
3670 }
3671 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3672 goto out;
3673 curagent->max_frame_size = atol(args[1]);
3674 if (curagent->max_frame_size < MIN_FRAME_SIZE ||
3675 curagent->max_frame_size > MAX_FRAME_SIZE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003676 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument in the range [%d, %d].\n",
3677 file, linenum, args[0], MIN_FRAME_SIZE, MAX_FRAME_SIZE);
Christopher Faulet2eca6b52017-02-27 09:40:34 +01003678 err_code |= ERR_ALERT | ERR_FATAL;
3679 goto out;
3680 }
3681 }
Christopher Faulete8ade382018-01-25 15:32:22 +01003682 else if (!strcmp(args[0], "max-waiting-frames")) {
3683 if (!*args[1]) {
3684 ha_alert("parsing [%s:%d] : '%s' expects an integer argument.\n",
3685 file, linenum, args[0]);
3686 err_code |= ERR_ALERT | ERR_FATAL;
3687 goto out;
3688 }
3689 if (alertif_too_many_args(1, file, linenum, args, &err_code))
3690 goto out;
3691 curagent->max_fpa = atol(args[1]);
3692 if (curagent->max_fpa < 1) {
3693 ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument.\n",
3694 file, linenum, args[0]);
3695 err_code |= ERR_ALERT | ERR_FATAL;
3696 goto out;
3697 }
3698 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003699 else if (!strcmp(args[0], "register-var-names")) {
3700 int cur_arg;
3701
3702 if (!*args[1]) {
3703 ha_alert("parsing [%s:%d] : '%s' expects one or more variable names.\n",
3704 file, linenum, args[0]);
3705 err_code |= ERR_ALERT | ERR_FATAL;
3706 goto out;
3707 }
3708 cur_arg = 1;
3709 while (*args[cur_arg]) {
3710 struct spoe_var_placeholder *vph;
3711
3712 if ((vph = calloc(1, sizeof(*vph))) == NULL) {
3713 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3714 err_code |= ERR_ALERT | ERR_ABORT;
3715 goto out;
3716 }
3717 if ((vph->name = strdup(args[cur_arg])) == NULL) {
Tim Duesterhusb2986132019-06-23 22:10:13 +02003718 free(vph);
Christopher Faulet336d3ef2017-12-22 10:00:55 +01003719 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
3720 err_code |= ERR_ALERT | ERR_ABORT;
3721 goto out;
3722 }
3723 LIST_ADDQ(&curvars, &vph->list);
3724 cur_arg++;
3725 }
3726 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02003727 else if (!strcmp(args[0], "log")) {
3728 char *errmsg = NULL;
3729
3730 if (!parse_logsrv(args, &curlogsrvs, (kwm == 1), &errmsg)) {
3731 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
3732 err_code |= ERR_ALERT | ERR_FATAL;
3733 goto out;
3734 }
3735 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003736 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003737 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-agent section.\n",
3738 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003739 err_code |= ERR_ALERT | ERR_FATAL;
3740 goto out;
3741 }
3742 out:
3743 return err_code;
3744}
Christopher Faulet11610f32017-09-21 10:23:10 +02003745static int
3746cfg_parse_spoe_group(const char *file, int linenum, char **args, int kwm)
3747{
3748 struct spoe_group *grp;
3749 const char *err;
3750 int err_code = 0;
3751
3752 if ((cfg_scope == NULL && curengine != NULL) ||
3753 (cfg_scope != NULL && curengine == NULL) ||
3754 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
3755 goto out;
3756
3757 if (!strcmp(args[0], "spoe-group")) { /* new spoe-group section */
3758 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003759 ha_alert("parsing [%s:%d] : missing name for spoe-group section.\n",
3760 file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003761 err_code |= ERR_ALERT | ERR_ABORT;
3762 goto out;
3763 }
3764 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3765 err_code |= ERR_ABORT;
3766 goto out;
3767 }
3768
3769 err = invalid_char(args[1]);
3770 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003771 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3772 file, linenum, *err, args[0], args[1]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003773 err_code |= ERR_ALERT | ERR_ABORT;
3774 goto out;
3775 }
3776
3777 list_for_each_entry(grp, &curgrps, list) {
3778 if (!strcmp(grp->id, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003779 ha_alert("parsing [%s:%d]: spoe-group section '%s' has the same"
3780 " name as another one declared at %s:%d.\n",
3781 file, linenum, args[1], grp->conf.file, grp->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02003782 err_code |= ERR_ALERT | ERR_FATAL;
3783 goto out;
3784 }
3785 }
3786
3787 if ((curgrp = calloc(1, sizeof(*curgrp))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003788 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003789 err_code |= ERR_ALERT | ERR_ABORT;
3790 goto out;
3791 }
3792
3793 curgrp->id = strdup(args[1]);
3794 curgrp->conf.file = strdup(file);
3795 curgrp->conf.line = linenum;
3796 LIST_INIT(&curgrp->phs);
3797 LIST_INIT(&curgrp->messages);
3798 LIST_ADDQ(&curgrps, &curgrp->list);
3799 }
3800 else if (!strcmp(args[0], "messages")) {
3801 int cur_arg = 1;
3802 while (*args[cur_arg]) {
3803 struct spoe_placeholder *ph = NULL;
3804
3805 list_for_each_entry(ph, &curgrp->phs, list) {
3806 if (!strcmp(ph->id, args[cur_arg])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003807 ha_alert("parsing [%s:%d]: spoe-message '%s' already used.\n",
3808 file, linenum, args[cur_arg]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003809 err_code |= ERR_ALERT | ERR_FATAL;
3810 goto out;
3811 }
3812 }
3813
3814 if ((ph = calloc(1, sizeof(*ph))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003815 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Faulet11610f32017-09-21 10:23:10 +02003816 err_code |= ERR_ALERT | ERR_ABORT;
3817 goto out;
3818 }
3819 ph->id = strdup(args[cur_arg]);
3820 LIST_ADDQ(&curgrp->phs, &ph->list);
3821 cur_arg++;
3822 }
3823 }
3824 else if (*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003825 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-group section.\n",
3826 file, linenum, args[0]);
Christopher Faulet11610f32017-09-21 10:23:10 +02003827 err_code |= ERR_ALERT | ERR_FATAL;
3828 goto out;
3829 }
3830 out:
3831 return err_code;
3832}
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003833
3834static int
3835cfg_parse_spoe_message(const char *file, int linenum, char **args, int kwm)
3836{
3837 struct spoe_message *msg;
3838 struct spoe_arg *arg;
3839 const char *err;
3840 char *errmsg = NULL;
3841 int err_code = 0;
3842
3843 if ((cfg_scope == NULL && curengine != NULL) ||
3844 (cfg_scope != NULL && curengine == NULL) ||
Christopher Faulete1405e52017-09-19 10:35:35 +02003845 (curengine != NULL && cfg_scope != NULL && strcmp(curengine, cfg_scope)))
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003846 goto out;
3847
3848 if (!strcmp(args[0], "spoe-message")) { /* new spoe-message section */
3849 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003850 ha_alert("parsing [%s:%d] : missing name for spoe-message section.\n",
3851 file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003852 err_code |= ERR_ALERT | ERR_ABORT;
3853 goto out;
3854 }
Christopher Fauletecc537a2017-02-23 22:52:39 +01003855 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
3856 err_code |= ERR_ABORT;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003857 goto out;
3858 }
3859
3860 err = invalid_char(args[1]);
3861 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003862 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
3863 file, linenum, *err, args[0], args[1]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003864 err_code |= ERR_ALERT | ERR_ABORT;
3865 goto out;
3866 }
3867
3868 list_for_each_entry(msg, &curmsgs, list) {
3869 if (!strcmp(msg->id, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003870 ha_alert("parsing [%s:%d]: spoe-message section '%s' has the same"
3871 " name as another one declared at %s:%d.\n",
3872 file, linenum, args[1], msg->conf.file, msg->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003873 err_code |= ERR_ALERT | ERR_FATAL;
3874 goto out;
3875 }
3876 }
3877
3878 if ((curmsg = calloc(1, sizeof(*curmsg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003879 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003880 err_code |= ERR_ALERT | ERR_ABORT;
3881 goto out;
3882 }
3883
3884 curmsg->id = strdup(args[1]);
3885 curmsg->id_len = strlen(curmsg->id);
3886 curmsg->event = SPOE_EV_NONE;
3887 curmsg->conf.file = strdup(file);
3888 curmsg->conf.line = linenum;
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003889 curmsg->nargs = 0;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003890 LIST_INIT(&curmsg->args);
Christopher Faulet57583e42017-09-04 15:41:09 +02003891 LIST_INIT(&curmsg->acls);
Christopher Faulet11610f32017-09-21 10:23:10 +02003892 LIST_INIT(&curmsg->by_evt);
3893 LIST_INIT(&curmsg->by_grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003894 LIST_ADDQ(&curmsgs, &curmsg->list);
3895 }
3896 else if (!strcmp(args[0], "args")) {
3897 int cur_arg = 1;
3898
3899 curproxy->conf.args.ctx = ARGC_SPOE;
3900 curproxy->conf.args.file = file;
3901 curproxy->conf.args.line = linenum;
3902 while (*args[cur_arg]) {
3903 char *delim = strchr(args[cur_arg], '=');
3904 int idx = 0;
3905
3906 if ((arg = calloc(1, sizeof(*arg))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003907 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003908 err_code |= ERR_ALERT | ERR_ABORT;
3909 goto out;
3910 }
3911
3912 if (!delim) {
3913 arg->name = NULL;
3914 arg->name_len = 0;
3915 delim = args[cur_arg];
3916 }
3917 else {
3918 arg->name = my_strndup(args[cur_arg], delim - args[cur_arg]);
3919 arg->name_len = delim - args[cur_arg];
3920 delim++;
3921 }
Christopher Fauletb0b42382017-02-23 22:41:09 +01003922 arg->expr = sample_parse_expr((char*[]){delim, NULL},
3923 &idx, file, linenum, &errmsg,
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01003924 &curproxy->conf.args, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003925 if (arg->expr == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003926 ha_alert("parsing [%s:%d] : '%s': %s.\n", file, linenum, args[0], errmsg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003927 err_code |= ERR_ALERT | ERR_FATAL;
3928 free(arg->name);
3929 free(arg);
3930 goto out;
3931 }
Christopher Fauletf51f5fa2017-01-19 10:01:12 +01003932 curmsg->nargs++;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003933 LIST_ADDQ(&curmsg->args, &arg->list);
3934 cur_arg++;
3935 }
3936 curproxy->conf.args.file = NULL;
3937 curproxy->conf.args.line = 0;
3938 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003939 else if (!strcmp(args[0], "acl")) {
3940 err = invalid_char(args[1]);
3941 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003942 ha_alert("parsing [%s:%d] : character '%c' is not permitted in acl name '%s'.\n",
3943 file, linenum, *err, args[1]);
Christopher Faulet57583e42017-09-04 15:41:09 +02003944 err_code |= ERR_ALERT | ERR_FATAL;
3945 goto out;
3946 }
Tim Duesterhus0cf811a2020-02-05 21:00:50 +01003947 if (strcasecmp(args[1], "or") == 0) {
Tim Duesterhusf1bc24c2020-02-06 22:04:03 +01003948 ha_alert("parsing [%s:%d] : acl name '%s' will never match. 'or' is used to express a "
Tim Duesterhus0cf811a2020-02-05 21:00:50 +01003949 "logical disjunction within a condition.\n",
3950 file, linenum, args[1]);
3951 err_code |= ERR_ALERT | ERR_FATAL;
3952 goto out;
3953 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003954 if (parse_acl((const char **)args + 1, &curmsg->acls, &errmsg, &curproxy->conf.args, file, linenum) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003955 ha_alert("parsing [%s:%d] : error detected while parsing ACL '%s' : %s.\n",
3956 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02003957 err_code |= ERR_ALERT | ERR_FATAL;
3958 goto out;
3959 }
3960 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003961 else if (!strcmp(args[0], "event")) {
3962 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003963 ha_alert("parsing [%s:%d] : missing event name.\n", file, linenum);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003964 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003965 goto out;
3966 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003967 /* if (alertif_too_many_args(1, file, linenum, args, &err_code)) */
3968 /* goto out; */
Christopher Fauletecc537a2017-02-23 22:52:39 +01003969
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003970 if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_CLIENT_SESS]))
3971 curmsg->event = SPOE_EV_ON_CLIENT_SESS;
3972 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_SERVER_SESS]))
3973 curmsg->event = SPOE_EV_ON_SERVER_SESS;
3974
3975 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_FE]))
3976 curmsg->event = SPOE_EV_ON_TCP_REQ_FE;
3977 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_REQ_BE]))
3978 curmsg->event = SPOE_EV_ON_TCP_REQ_BE;
3979 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_TCP_RSP]))
3980 curmsg->event = SPOE_EV_ON_TCP_RSP;
3981
3982 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_FE]))
3983 curmsg->event = SPOE_EV_ON_HTTP_REQ_FE;
3984 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_REQ_BE]))
3985 curmsg->event = SPOE_EV_ON_HTTP_REQ_BE;
3986 else if (!strcmp(args[1], spoe_event_str[SPOE_EV_ON_HTTP_RSP]))
3987 curmsg->event = SPOE_EV_ON_HTTP_RSP;
3988 else {
Joseph Herlantf1da69d2018-11-15 13:49:02 -08003989 ha_alert("parsing [%s:%d] : unknown event '%s'.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003990 file, linenum, args[1]);
Christopher Fauletecc537a2017-02-23 22:52:39 +01003991 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02003992 goto out;
3993 }
Christopher Faulet57583e42017-09-04 15:41:09 +02003994
3995 if (strcmp(args[2], "if") == 0 || strcmp(args[2], "unless") == 0) {
3996 struct acl_cond *cond;
3997
3998 cond = build_acl_cond(file, linenum, &curmsg->acls,
3999 curproxy, (const char **)args+2,
4000 &errmsg);
4001 if (cond == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004002 ha_alert("parsing [%s:%d] : error detected while "
4003 "parsing an 'event %s' condition : %s.\n",
4004 file, linenum, args[1], errmsg);
Christopher Faulet57583e42017-09-04 15:41:09 +02004005 err_code |= ERR_ALERT | ERR_FATAL;
4006 goto out;
4007 }
4008 curmsg->cond = cond;
4009 }
4010 else if (*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004011 ha_alert("parsing [%s:%d]: 'event %s' expects either 'if' "
4012 "or 'unless' followed by a condition but found '%s'.\n",
4013 file, linenum, args[1], args[2]);
Christopher Faulet57583e42017-09-04 15:41:09 +02004014 err_code |= ERR_ALERT | ERR_FATAL;
4015 goto out;
4016 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004017 }
4018 else if (!*args[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004019 ha_alert("parsing [%s:%d] : unknown keyword '%s' in spoe-message section.\n",
4020 file, linenum, args[0]);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004021 err_code |= ERR_ALERT | ERR_FATAL;
4022 goto out;
4023 }
4024 out:
4025 free(errmsg);
4026 return err_code;
4027}
4028
4029/* Return -1 on error, else 0 */
4030static int
4031parse_spoe_flt(char **args, int *cur_arg, struct proxy *px,
4032 struct flt_conf *fconf, char **err, void *private)
4033{
4034 struct list backup_sections;
4035 struct spoe_config *conf;
4036 struct spoe_message *msg, *msgback;
Christopher Faulet11610f32017-09-21 10:23:10 +02004037 struct spoe_group *grp, *grpback;
4038 struct spoe_placeholder *ph, *phback;
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004039 struct spoe_var_placeholder *vph, *vphback;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004040 struct logsrv *logsrv, *logsrvback;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004041 char *file = NULL, *engine = NULL;
4042 int ret, pos = *cur_arg + 1;
4043
Christopher Faulet84c844e2018-03-23 14:37:14 +01004044 LIST_INIT(&curmsgs);
4045 LIST_INIT(&curgrps);
4046 LIST_INIT(&curmphs);
4047 LIST_INIT(&curgphs);
4048 LIST_INIT(&curvars);
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004049 LIST_INIT(&curlogsrvs);
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004050 curpxopts = 0;
4051 curpxopts2 = 0;
Christopher Faulet84c844e2018-03-23 14:37:14 +01004052
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004053 conf = calloc(1, sizeof(*conf));
4054 if (conf == NULL) {
4055 memprintf(err, "%s: out of memory", args[*cur_arg]);
4056 goto error;
4057 }
4058 conf->proxy = px;
4059
4060 while (*args[pos]) {
4061 if (!strcmp(args[pos], "config")) {
4062 if (!*args[pos+1]) {
4063 memprintf(err, "'%s' : '%s' option without value",
4064 args[*cur_arg], args[pos]);
4065 goto error;
4066 }
4067 file = args[pos+1];
4068 pos += 2;
4069 }
4070 else if (!strcmp(args[pos], "engine")) {
4071 if (!*args[pos+1]) {
4072 memprintf(err, "'%s' : '%s' option without value",
4073 args[*cur_arg], args[pos]);
4074 goto error;
4075 }
4076 engine = args[pos+1];
4077 pos += 2;
4078 }
4079 else {
4080 memprintf(err, "unknown keyword '%s'", args[pos]);
4081 goto error;
4082 }
4083 }
4084 if (file == NULL) {
4085 memprintf(err, "'%s' : missing config file", args[*cur_arg]);
4086 goto error;
4087 }
4088
4089 /* backup sections and register SPOE sections */
4090 LIST_INIT(&backup_sections);
4091 cfg_backup_sections(&backup_sections);
Christopher Faulet11610f32017-09-21 10:23:10 +02004092 cfg_register_section("spoe-agent", cfg_parse_spoe_agent, NULL);
4093 cfg_register_section("spoe-group", cfg_parse_spoe_group, NULL);
William Lallemandd2ff56d2017-10-16 11:06:50 +02004094 cfg_register_section("spoe-message", cfg_parse_spoe_message, NULL);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004095
4096 /* Parse SPOE filter configuration file */
4097 curengine = engine;
4098 curproxy = px;
4099 curagent = NULL;
4100 curmsg = NULL;
4101 ret = readcfgfile(file);
4102 curproxy = NULL;
4103
4104 /* unregister SPOE sections and restore previous sections */
4105 cfg_unregister_sections();
4106 cfg_restore_sections(&backup_sections);
4107
4108 if (ret == -1) {
4109 memprintf(err, "Could not open configuration file %s : %s",
4110 file, strerror(errno));
4111 goto error;
4112 }
4113 if (ret & (ERR_ABORT|ERR_FATAL)) {
4114 memprintf(err, "Error(s) found in configuration file %s", file);
4115 goto error;
4116 }
4117
4118 /* Check SPOE agent */
4119 if (curagent == NULL) {
4120 memprintf(err, "No SPOE agent found in file %s", file);
4121 goto error;
4122 }
4123 if (curagent->b.name == NULL) {
4124 memprintf(err, "No backend declared for SPOE agent '%s' declared at %s:%d",
4125 curagent->id, curagent->conf.file, curagent->conf.line);
4126 goto error;
4127 }
Christopher Fauletf7a30922016-11-10 15:04:51 +01004128 if (curagent->timeout.hello == TICK_ETERNITY ||
4129 curagent->timeout.idle == TICK_ETERNITY ||
Christopher Fauletf7a30922016-11-10 15:04:51 +01004130 curagent->timeout.processing == TICK_ETERNITY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004131 ha_warning("Proxy '%s': missing timeouts for SPOE agent '%s' declare at %s:%d.\n"
4132 " | While not properly invalid, you will certainly encounter various problems\n"
4133 " | with such a configuration. To fix this, please ensure that all following\n"
4134 " | timeouts are set to a non-zero value: 'hello', 'idle', 'processing'.\n",
4135 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004136 }
4137 if (curagent->var_pfx == NULL) {
4138 char *tmp = curagent->id;
4139
4140 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +01004141 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004142 memprintf(err, "Invalid variable prefix '%s' for SPOE agent '%s' declared at %s:%d. "
4143 "Use 'option var-prefix' to set it. Only [a-zA-Z0-9_.] chars are supported.\n",
4144 curagent->id, curagent->id, curagent->conf.file, curagent->conf.line);
4145 goto error;
4146 }
4147 tmp++;
4148 }
4149 curagent->var_pfx = strdup(curagent->id);
4150 }
4151
Christopher Fauletb7426d12018-03-21 14:12:17 +01004152 if (curagent->var_on_error) {
4153 struct arg arg;
4154
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004155 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Fauletb7426d12018-03-21 14:12:17 +01004156 curagent->var_pfx, curagent->var_on_error);
4157
4158 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004159 arg.data.str.area = trash.area;
4160 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004161 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Fauletb7426d12018-03-21 14:12:17 +01004162 if (!vars_check_arg(&arg, err)) {
4163 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4164 curagent->id, curagent->var_pfx, curagent->var_on_error, *err);
4165 goto error;
4166 }
4167 }
4168
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004169 if (curagent->var_t_process) {
4170 struct arg arg;
4171
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004172 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004173 curagent->var_pfx, curagent->var_t_process);
4174
4175 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004176 arg.data.str.area = trash.area;
4177 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004178 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004179 if (!vars_check_arg(&arg, err)) {
4180 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4181 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4182 goto error;
4183 }
4184 }
4185
4186 if (curagent->var_t_total) {
4187 struct arg arg;
4188
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004189 trash.data = snprintf(trash.area, trash.size, "txn.%s.%s",
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004190 curagent->var_pfx, curagent->var_t_total);
4191
4192 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004193 arg.data.str.area = trash.area;
4194 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004195 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet36bda1c2018-03-22 09:08:20 +01004196 if (!vars_check_arg(&arg, err)) {
4197 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4198 curagent->id, curagent->var_pfx, curagent->var_t_process, *err);
4199 goto error;
4200 }
4201 }
4202
Christopher Faulet11610f32017-09-21 10:23:10 +02004203 if (LIST_ISEMPTY(&curmphs) && LIST_ISEMPTY(&curgphs)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004204 ha_warning("Proxy '%s': No message/group used by SPOE agent '%s' declared at %s:%d.\n",
4205 px->id, curagent->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004206 goto finish;
4207 }
4208
Christopher Faulet11610f32017-09-21 10:23:10 +02004209 /* Replace placeholders by the corresponding messages for the SPOE
4210 * agent */
4211 list_for_each_entry(ph, &curmphs, list) {
4212 list_for_each_entry(msg, &curmsgs, list) {
Christopher Fauleta21b0642017-01-09 16:56:23 +01004213 struct spoe_arg *arg;
4214 unsigned int where;
4215
Christopher Faulet11610f32017-09-21 10:23:10 +02004216 if (!strcmp(msg->id, ph->id)) {
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004217 if ((px->cap & (PR_CAP_FE|PR_CAP_BE)) == (PR_CAP_FE|PR_CAP_BE)) {
4218 if (msg->event == SPOE_EV_ON_TCP_REQ_BE)
4219 msg->event = SPOE_EV_ON_TCP_REQ_FE;
4220 if (msg->event == SPOE_EV_ON_HTTP_REQ_BE)
4221 msg->event = SPOE_EV_ON_HTTP_REQ_FE;
4222 }
4223 if (!(px->cap & PR_CAP_FE) && (msg->event == SPOE_EV_ON_CLIENT_SESS ||
4224 msg->event == SPOE_EV_ON_TCP_REQ_FE ||
4225 msg->event == SPOE_EV_ON_HTTP_REQ_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004226 ha_warning("Proxy '%s': frontend event used on a backend proxy at %s:%d.\n",
4227 px->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004228 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004229 }
4230 if (msg->event == SPOE_EV_NONE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004231 ha_warning("Proxy '%s': Ignore SPOE message '%s' without event at %s:%d.\n",
4232 px->id, msg->id, msg->conf.file, msg->conf.line);
Christopher Faulet11610f32017-09-21 10:23:10 +02004233 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004234 }
Christopher Fauleta21b0642017-01-09 16:56:23 +01004235
4236 where = 0;
4237 switch (msg->event) {
4238 case SPOE_EV_ON_CLIENT_SESS:
4239 where |= SMP_VAL_FE_CON_ACC;
4240 break;
4241
4242 case SPOE_EV_ON_TCP_REQ_FE:
4243 where |= SMP_VAL_FE_REQ_CNT;
4244 break;
4245
4246 case SPOE_EV_ON_HTTP_REQ_FE:
4247 where |= SMP_VAL_FE_HRQ_HDR;
4248 break;
4249
4250 case SPOE_EV_ON_TCP_REQ_BE:
4251 if (px->cap & PR_CAP_FE)
4252 where |= SMP_VAL_FE_REQ_CNT;
4253 if (px->cap & PR_CAP_BE)
4254 where |= SMP_VAL_BE_REQ_CNT;
4255 break;
4256
4257 case SPOE_EV_ON_HTTP_REQ_BE:
4258 if (px->cap & PR_CAP_FE)
4259 where |= SMP_VAL_FE_HRQ_HDR;
4260 if (px->cap & PR_CAP_BE)
4261 where |= SMP_VAL_BE_HRQ_HDR;
4262 break;
4263
4264 case SPOE_EV_ON_SERVER_SESS:
4265 where |= SMP_VAL_BE_SRV_CON;
4266 break;
4267
4268 case SPOE_EV_ON_TCP_RSP:
4269 if (px->cap & PR_CAP_FE)
4270 where |= SMP_VAL_FE_RES_CNT;
4271 if (px->cap & PR_CAP_BE)
4272 where |= SMP_VAL_BE_RES_CNT;
4273 break;
4274
4275 case SPOE_EV_ON_HTTP_RSP:
4276 if (px->cap & PR_CAP_FE)
4277 where |= SMP_VAL_FE_HRS_HDR;
4278 if (px->cap & PR_CAP_BE)
4279 where |= SMP_VAL_BE_HRS_HDR;
4280 break;
4281
4282 default:
4283 break;
4284 }
4285
4286 list_for_each_entry(arg, &msg->args, list) {
4287 if (!(arg->expr->fetch->val & where)) {
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004288 memprintf(err, "Ignore SPOE message '%s' at %s:%d: "
Christopher Fauleta21b0642017-01-09 16:56:23 +01004289 "some args extract information from '%s', "
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004290 "none of which is available here ('%s')",
4291 msg->id, msg->conf.file, msg->conf.line,
Christopher Fauleta21b0642017-01-09 16:56:23 +01004292 sample_ckp_names(arg->expr->fetch->use),
4293 sample_ckp_names(where));
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004294 goto error;
Christopher Fauleta21b0642017-01-09 16:56:23 +01004295 }
4296 }
4297
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004298 msg->agent = curagent;
Christopher Faulet11610f32017-09-21 10:23:10 +02004299 LIST_ADDQ(&curagent->events[msg->event], &msg->by_evt);
4300 goto next_mph;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004301 }
4302 }
4303 memprintf(err, "SPOE agent '%s' try to use undefined SPOE message '%s' at %s:%d",
Christopher Faulet11610f32017-09-21 10:23:10 +02004304 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004305 goto error;
Christopher Faulet11610f32017-09-21 10:23:10 +02004306 next_mph:
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004307 continue;
4308 }
4309
Christopher Faulet11610f32017-09-21 10:23:10 +02004310 /* Replace placeholders by the corresponding groups for the SPOE
4311 * agent */
4312 list_for_each_entry(ph, &curgphs, list) {
4313 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4314 if (!strcmp(grp->id, ph->id)) {
4315 grp->agent = curagent;
4316 LIST_DEL(&grp->list);
4317 LIST_ADDQ(&curagent->groups, &grp->list);
4318 goto next_aph;
4319 }
4320 }
4321 memprintf(err, "SPOE agent '%s' try to use undefined SPOE group '%s' at %s:%d",
4322 curagent->id, ph->id, curagent->conf.file, curagent->conf.line);
4323 goto error;
4324 next_aph:
4325 continue;
4326 }
4327
4328 /* Replace placeholders by the corresponding message for each SPOE
4329 * group of the SPOE agent */
4330 list_for_each_entry(grp, &curagent->groups, list) {
4331 list_for_each_entry_safe(ph, phback, &grp->phs, list) {
4332 list_for_each_entry(msg, &curmsgs, list) {
4333 if (!strcmp(msg->id, ph->id)) {
4334 if (msg->group != NULL) {
4335 memprintf(err, "SPOE message '%s' already belongs to "
4336 "the SPOE group '%s' declare at %s:%d",
4337 msg->id, msg->group->id,
4338 msg->group->conf.file,
4339 msg->group->conf.line);
4340 goto error;
4341 }
4342
4343 /* Scope for arguments are not checked for now. We will check
4344 * them only if a rule use the corresponding SPOE group. */
4345 msg->agent = curagent;
4346 msg->group = grp;
4347 LIST_DEL(&ph->list);
4348 LIST_ADDQ(&grp->messages, &msg->by_grp);
4349 goto next_mph_grp;
4350 }
4351 }
4352 memprintf(err, "SPOE group '%s' try to use undefined SPOE message '%s' at %s:%d",
4353 grp->id, ph->id, curagent->conf.file, curagent->conf.line);
4354 goto error;
4355 next_mph_grp:
4356 continue;
4357 }
4358 }
4359
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004360 finish:
Christopher Faulet11610f32017-09-21 10:23:10 +02004361 /* move curmsgs to the agent message list */
4362 curmsgs.n->p = &curagent->messages;
4363 curmsgs.p->n = &curagent->messages;
4364 curagent->messages = curmsgs;
4365 LIST_INIT(&curmsgs);
4366
Christopher Faulet7ee86672017-09-19 11:08:28 +02004367 conf->id = strdup(engine ? engine : curagent->id);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004368 conf->agent = curagent;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004369
4370 /* Start agent's proxy initialization here. It will be finished during
4371 * the filter init. */
4372 memset(&conf->agent_fe, 0, sizeof(conf->agent_fe));
4373 init_new_proxy(&conf->agent_fe);
4374 conf->agent_fe.id = conf->agent->id;
4375 conf->agent_fe.parent = conf->agent;
Christopher Faulet0e0f0852018-03-26 17:20:36 +02004376 conf->agent_fe.options |= curpxopts;
4377 conf->agent_fe.options2 |= curpxopts2;
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004378
4379 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4380 LIST_DEL(&logsrv->list);
4381 LIST_ADDQ(&conf->agent_fe.logsrvs, &logsrv->list);
4382 }
4383
Christopher Faulet11610f32017-09-21 10:23:10 +02004384 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4385 LIST_DEL(&ph->list);
4386 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004387 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004388 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4389 LIST_DEL(&ph->list);
4390 spoe_release_placeholder(ph);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004391 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004392 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4393 struct arg arg;
4394
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004395 trash.data = snprintf(trash.area, trash.size, "proc.%s.%s",
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004396 curagent->var_pfx, vph->name);
4397
4398 arg.type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004399 arg.data.str.area = trash.area;
4400 arg.data.str.data = trash.data;
Christopher Fauletbf9bcb02019-05-13 10:39:36 +02004401 arg.data.str.size = 0; /* Set it to 0 to not release it in vars_check_args() */
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004402 if (!vars_check_arg(&arg, err)) {
4403 memprintf(err, "SPOE agent '%s': failed to register variable %s.%s (%s)",
4404 curagent->id, curagent->var_pfx, vph->name, *err);
4405 goto error;
4406 }
4407
4408 LIST_DEL(&vph->list);
4409 free(vph->name);
4410 free(vph);
4411 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004412 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4413 LIST_DEL(&grp->list);
4414 spoe_release_group(grp);
4415 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004416 *cur_arg = pos;
Christopher Faulet3b386a32017-02-23 10:17:15 +01004417 fconf->id = spoe_filter_id;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004418 fconf->ops = &spoe_ops;
4419 fconf->conf = conf;
4420 return 0;
4421
4422 error:
Christopher Faulet8ef75252017-02-20 22:56:03 +01004423 spoe_release_agent(curagent);
Christopher Faulet11610f32017-09-21 10:23:10 +02004424 list_for_each_entry_safe(ph, phback, &curmphs, list) {
4425 LIST_DEL(&ph->list);
4426 spoe_release_placeholder(ph);
4427 }
4428 list_for_each_entry_safe(ph, phback, &curgphs, list) {
4429 LIST_DEL(&ph->list);
4430 spoe_release_placeholder(ph);
4431 }
Christopher Faulet336d3ef2017-12-22 10:00:55 +01004432 list_for_each_entry_safe(vph, vphback, &curvars, list) {
4433 LIST_DEL(&vph->list);
4434 free(vph->name);
4435 free(vph);
4436 }
Christopher Faulet11610f32017-09-21 10:23:10 +02004437 list_for_each_entry_safe(grp, grpback, &curgrps, list) {
4438 LIST_DEL(&grp->list);
4439 spoe_release_group(grp);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004440 }
4441 list_for_each_entry_safe(msg, msgback, &curmsgs, list) {
4442 LIST_DEL(&msg->list);
Christopher Faulet8ef75252017-02-20 22:56:03 +01004443 spoe_release_message(msg);
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004444 }
Christopher Faulet7250b8f2018-03-26 17:19:01 +02004445 list_for_each_entry_safe(logsrv, logsrvback, &curlogsrvs, list) {
4446 LIST_DEL(&logsrv->list);
4447 free(logsrv);
4448 }
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004449 free(conf);
4450 return -1;
4451}
4452
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004453/* Send message of a SPOE group. This is the action_ptr callback of a rule
4454 * associated to a "send-spoe-group" action.
4455 *
Christopher Faulet13403762019-12-13 09:01:57 +01004456 * It returns ACT_RET_CONT if processing is finished (with error or not), it returns
4457 * ACT_RET_YIELD if the action is in progress. */
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004458static enum act_return
4459spoe_send_group(struct act_rule *rule, struct proxy *px,
4460 struct session *sess, struct stream *s, int flags)
4461{
4462 struct filter *filter;
4463 struct spoe_agent *agent = NULL;
4464 struct spoe_group *group = NULL;
4465 struct spoe_context *ctx = NULL;
4466 int ret, dir;
4467
4468 list_for_each_entry(filter, &s->strm_flt.filters, list) {
4469 if (filter->config == rule->arg.act.p[0]) {
4470 agent = rule->arg.act.p[2];
4471 group = rule->arg.act.p[3];
4472 ctx = filter->ctx;
4473 break;
4474 }
4475 }
4476 if (agent == NULL || group == NULL || ctx == NULL)
Christopher Faulet13403762019-12-13 09:01:57 +01004477 return ACT_RET_CONT;
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004478 if (ctx->state == SPOE_CTX_ST_NONE)
4479 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004480
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004481 switch (rule->from) {
4482 case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break;
4483 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
4484 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
4485 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
4486 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
4487 default:
4488 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4489 " - internal error while execute spoe-send-group\n",
4490 (int)now.tv_sec, (int)now.tv_usec, agent->id,
4491 __FUNCTION__, s);
4492 send_log(px, LOG_ERR, "SPOE: [%s] internal error while execute spoe-send-group\n",
4493 agent->id);
4494 return ACT_RET_CONT;
4495 }
4496
4497 ret = spoe_process_group(s, ctx, group, dir);
4498 if (ret == 1)
4499 return ACT_RET_CONT;
4500 else if (ret == 0) {
Christopher Faulet105ba6c2019-12-18 14:41:51 +01004501 if (flags & ACT_OPT_FINAL) {
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004502 SPOE_PRINTF(stderr, "%d.%06d [SPOE/%-15s] %s: stream=%p"
4503 " - failed to process group '%s': interrupted by caller\n",
4504 (int)now.tv_sec, (int)now.tv_usec,
4505 agent->id, __FUNCTION__, s, group->id);
4506 ctx->status_code = SPOE_CTX_ERR_INTERRUPT;
Christopher Faulet6f9ea4f2018-01-24 16:13:48 +01004507 spoe_stop_processing(agent, ctx);
Christopher Fauletcaf2fec2018-04-04 10:25:50 +02004508 spoe_handle_processing_error(s, agent, ctx, dir);
Christopher Faulet344c4ab2017-09-22 10:20:13 +02004509 return ACT_RET_CONT;
4510 }
4511 return ACT_RET_YIELD;
4512 }
4513 else
Christopher Faulet13403762019-12-13 09:01:57 +01004514 return ACT_RET_CONT;
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004515}
4516
4517/* Check an "send-spoe-group" action. Here, we'll try to find the real SPOE
4518 * group associated to <rule>. The format of an rule using 'send-spoe-group'
4519 * action should be:
4520 *
4521 * (http|tcp)-(request|response) send-spoe-group <engine-id> <group-id>
4522 *
4523 * So, we'll loop on each configured SPOE filter for the proxy <px> to find the
4524 * SPOE engine matching <engine-id>. And then, we'll try to find the good group
4525 * matching <group-id>. Finally, we'll check all messages referenced by the SPOE
4526 * group.
4527 *
4528 * The function returns 1 in success case, otherwise, it returns 0 and err is
4529 * filled.
4530 */
4531static int
4532check_send_spoe_group(struct act_rule *rule, struct proxy *px, char **err)
4533{
4534 struct flt_conf *fconf;
4535 struct spoe_config *conf;
4536 struct spoe_agent *agent = NULL;
4537 struct spoe_group *group;
4538 struct spoe_message *msg;
4539 char *engine_id = rule->arg.act.p[0];
4540 char *group_id = rule->arg.act.p[1];
4541 unsigned int where = 0;
4542
4543 switch (rule->from) {
4544 case ACT_F_TCP_REQ_SES: where = SMP_VAL_FE_SES_ACC; break;
4545 case ACT_F_TCP_REQ_CNT: where = SMP_VAL_FE_REQ_CNT; break;
4546 case ACT_F_TCP_RES_CNT: where = SMP_VAL_BE_RES_CNT; break;
4547 case ACT_F_HTTP_REQ: where = SMP_VAL_FE_HRQ_HDR; break;
4548 case ACT_F_HTTP_RES: where = SMP_VAL_BE_HRS_HDR; break;
4549 default:
4550 memprintf(err,
4551 "internal error, unexpected rule->from=%d, please report this bug!",
4552 rule->from);
4553 goto error;
4554 }
4555
4556 /* Try to find the SPOE engine by checking all SPOE filters for proxy
4557 * <px> */
4558 list_for_each_entry(fconf, &px->filter_configs, list) {
4559 conf = fconf->conf;
4560
4561 /* This is not an SPOE filter */
4562 if (fconf->id != spoe_filter_id)
4563 continue;
4564
4565 /* This is the good engine */
4566 if (!strcmp(conf->id, engine_id)) {
4567 agent = conf->agent;
4568 break;
4569 }
4570 }
4571 if (agent == NULL) {
4572 memprintf(err, "unable to find SPOE engine '%s' used by the send-spoe-group '%s'",
4573 engine_id, group_id);
4574 goto error;
4575 }
4576
4577 /* Try to find the right group */
4578 list_for_each_entry(group, &agent->groups, list) {
4579 /* This is the good group */
4580 if (!strcmp(group->id, group_id))
4581 break;
4582 }
4583 if (&group->list == &agent->groups) {
4584 memprintf(err, "unable to find SPOE group '%s' into SPOE engine '%s' configuration",
4585 group_id, engine_id);
4586 goto error;
4587 }
4588
4589 /* Ok, we found the group, we need to check messages and their
4590 * arguments */
4591 list_for_each_entry(msg, &group->messages, by_grp) {
4592 struct spoe_arg *arg;
4593
4594 list_for_each_entry(arg, &msg->args, list) {
4595 if (!(arg->expr->fetch->val & where)) {
4596 memprintf(err, "Invalid SPOE message '%s' used by SPOE group '%s' at %s:%d: "
4597 "some args extract information from '%s',"
4598 "none of which is available here ('%s')",
4599 msg->id, group->id, msg->conf.file, msg->conf.line,
4600 sample_ckp_names(arg->expr->fetch->use),
4601 sample_ckp_names(where));
4602 goto error;
4603 }
4604 }
4605 }
4606
4607 free(engine_id);
4608 free(group_id);
4609 rule->arg.act.p[0] = fconf; /* Associate filter config with the rule */
4610 rule->arg.act.p[1] = conf; /* Associate SPOE config with the rule */
4611 rule->arg.act.p[2] = agent; /* Associate SPOE agent with the rule */
4612 rule->arg.act.p[3] = group; /* Associate SPOE group with the rule */
4613 return 1;
4614
4615 error:
4616 free(engine_id);
4617 free(group_id);
4618 return 0;
4619}
4620
4621/* Parse 'send-spoe-group' action following the format:
4622 *
4623 * ... send-spoe-group <engine-id> <group-id>
4624 *
4625 * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error
4626 * message. Otherwise, it returns ACT_RET_PRS_OK and parsing engine and group
4627 * ids are saved and used later, when the rule will be checked.
4628 */
4629static enum act_parse_ret
4630parse_send_spoe_group(const char **args, int *orig_arg, struct proxy *px,
4631 struct act_rule *rule, char **err)
4632{
4633 if (!*args[*orig_arg] || !*args[*orig_arg+1] ||
4634 (*args[*orig_arg+2] && strcmp(args[*orig_arg+2], "if") != 0 && strcmp(args[*orig_arg+2], "unless") != 0)) {
4635 memprintf(err, "expects 2 arguments: <engine-id> <group-id>");
4636 return ACT_RET_PRS_ERR;
4637 }
4638 rule->arg.act.p[0] = strdup(args[*orig_arg]); /* Copy the SPOE engine id */
4639 rule->arg.act.p[1] = strdup(args[*orig_arg+1]); /* Cope the SPOE group id */
4640
4641 (*orig_arg) += 2;
4642
4643 rule->action = ACT_CUSTOM;
4644 rule->action_ptr = spoe_send_group;
4645 rule->check_ptr = check_send_spoe_group;
4646 return ACT_RET_PRS_OK;
4647}
4648
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02004649
4650/* Declare the filter parser for "spoe" keyword */
4651static struct flt_kw_list flt_kws = { "SPOE", { }, {
4652 { "spoe", parse_spoe_flt, NULL },
4653 { NULL, NULL, NULL },
4654 }
4655};
4656
Willy Tarreau0108d902018-11-25 19:14:37 +01004657INITCALL1(STG_REGISTER, flt_register_keywords, &flt_kws);
4658
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004659/* Delcate the action parser for "spoe-action" keyword */
4660static struct action_kw_list tcp_req_action_kws = { { }, {
4661 { "send-spoe-group", parse_send_spoe_group },
4662 { /* END */ },
4663 }
4664};
Willy Tarreau0108d902018-11-25 19:14:37 +01004665
4666INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_action_kws);
4667
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004668static struct action_kw_list tcp_res_action_kws = { { }, {
4669 { "send-spoe-group", parse_send_spoe_group },
4670 { /* END */ },
4671 }
4672};
Willy Tarreau0108d902018-11-25 19:14:37 +01004673
4674INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_action_kws);
4675
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004676static struct action_kw_list http_req_action_kws = { { }, {
4677 { "send-spoe-group", parse_send_spoe_group },
4678 { /* END */ },
4679 }
4680};
Willy Tarreau0108d902018-11-25 19:14:37 +01004681
4682INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_action_kws);
4683
Christopher Faulet76c09ef2017-09-21 11:03:52 +02004684static struct action_kw_list http_res_action_kws = { { }, {
4685 { "send-spoe-group", parse_send_spoe_group },
4686 { /* END */ },
4687 }
4688};
4689
Willy Tarreau0108d902018-11-25 19:14:37 +01004690INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_action_kws);