#include <haproxy/task-t.h>
#include <haproxy/thread-t.h>
-/* Type of list of messages */
-#define SPOE_MSGS_BY_EVENT 0x01
-#define SPOE_MSGS_BY_GROUP 0x02
+/* Reserved 4 bytes to the frame size. So a frame and its size can be written
+ * together in a buffer */
+#define SPOP_MAX_FRAME_SIZE global.tune.bufsize - 4
+
+/* The minimum size for a frame */
+#define SPOP_MIN_FRAME_SIZE 256
+
+/* Reserved for the metadata and the frame type.
+ * So <SPOP_MAX_FRAME_SIZE> - <FRAME_HDR_SIZE> is the maximum payload size */
+#define SPOP_FRAME_HDR_SIZE 32
+
+/* Flags set on the SPOP frame */
+#define SPOP_FRM_FL_FIN 0x00000001
+#define SPOP_FRM_FL_ABRT 0x00000002
+
-/* Flags set on the SPOE agent */
+/* All supported SPOP actions */
+enum spoe_action_type {
+ SPOP_ACT_T_SET_VAR = 1,
+ SPOP_ACT_T_UNSET_VAR,
+ SPOP_ACT_TYPES,
+};
+
+/* SPOP Errors */
+enum spop_error {
+ SPOP_ERR_NONE = 0x00,
+ SPOP_ERR_IO = 0x01,
+ SPOP_ERR_TOUT = 0x02,
+ SPOP_ERR_TOO_BIG = 0x03,
+ SPOP_ERR_INVALID = 0x04,
+ SPOP_ERR_NO_VSN = 0x05,
+ SPOP_ERR_NO_FRAME_SIZE = 0x06,
+ SPOP_ERR_NO_CAP = 0x07,
+ SPOP_ERR_BAD_VSN = 0x08,
+ SPOP_ERR_BAD_FRAME_SIZE = 0x09,
+ SPOP_ERR_FRAG_NOT_SUPPORTED = 0x0a,
+ SPOP_ERR_INTERLACED_FRAMES = 0x0b,
+ SPOP_ERR_FRAMEID_NOTFOUND = 0x0c,
+ SPOP_ERR_RES = 0x0d,
+ SPOP_ERR_UNKNOWN = 0x63,
+ SPOP_ERR_ENTRIES,
+};
+
+/* Scopes used for variables set by agents. It is a way to be agnotic to vars
+ * scope. */
+enum spop_vars_scope {
+ SPOP_SCOPE_PROC = 0, /* <=> SCOPE_PROC */
+ SPOP_SCOPE_SESS, /* <=> SCOPE_SESS */
+ SPOP_SCOPE_TXN, /* <=> SCOPE_TXN */
+ SPOP_SCOPE_REQ, /* <=> SCOPE_REQ */
+ SPOP_SCOPE_RES, /* <=> SCOPE_RES */
+};
+
+/* Masks to get SPOP data type or flags value */
+#define SPOP_DATA_T_MASK 0x0F
+#define SPOP_DATA_FL_MASK 0xF0
+
+/* SPOP data flags to set Boolean values */
+#define SPOP_DATA_FL_FALSE 0x00
+#define SPOP_DATA_FL_TRUE 0x10
+
+/* All supported SPOP data types */
+enum spop_data_type {
+ SPOP_DATA_T_NULL = 0,
+ SPOP_DATA_T_BOOL,
+ SPOP_DATA_T_INT32,
+ SPOP_DATA_T_UINT32,
+ SPOP_DATA_T_INT64,
+ SPOP_DATA_T_UINT64,
+ SPOP_DATA_T_IPV4,
+ SPOP_DATA_T_IPV6,
+ SPOP_DATA_T_STR,
+ SPOP_DATA_T_BIN,
+ SPOP_DATA_TYPES
+};
+
+/* SPOP Frame Types */
+enum spop_frame_type {
+ SPOP_FRM_T_UNSET = 0,
+
+ /* Frames sent by HAProxy */
+ SPOP_FRM_T_HAPROXY_HELLO = 1,
+ SPOP_FRM_T_HAPROXY_DISCON,
+ SPOP_FRM_T_HAPROXY_NOTIFY,
+
+ /* Frames sent by the agents */
+ SPOP_FRM_T_AGENT_HELLO = 101,
+ SPOP_FRM_T_AGENT_DISCON,
+ SPOP_FRM_T_AGENT_ACK
+};
+
+/* SPOE agent flags */
#define SPOE_FL_CONT_ON_ERR 0x00000001 /* Do not stop events processing when an error occurred */
#define SPOE_FL_PIPELINING 0x00000002 /* Set when SPOE agent supports pipelining (set by default) */
-/* unused 0x00000004 */
-/* unsused 0x00000008 */
-/* unused 0x00000010 */
+/* unused 0x00000004..0x00000010 */
#define SPOE_FL_FORCE_SET_VAR 0x00000020 /* Set when SPOE agent will set all variables from agent (and not only known variables) */
+/* Type of list of messages */
+#define SPOE_MSGS_BY_EVENT 0x01
+#define SPOE_MSGS_BY_GROUP 0x02
+
/* Flags set on the SPOE context */
#define SPOE_CTX_FL_CLI_CONNECTED 0x00000001 /* Set after that on-client-session event was processed */
#define SPOE_CTX_FL_SRV_CONNECTED 0x00000002 /* Set after that on-server-session event was processed */
#define SPOE_APPCTX_ERR_NONE 0x00000000 /* no error yet, leave it to zero */
#define SPOE_APPCTX_ERR_TOUT 0x00000001 /* SPOE applet timeout */
-/* Flags set on the SPOE frame */
-#define SPOE_FRM_FL_FIN 0x00000001
-#define SPOE_FRM_FL_ABRT 0x00000002
-
-/* Masks to get data type or flags value */
-#define SPOE_DATA_T_MASK 0x0F
-#define SPOE_DATA_FL_MASK 0xF0
-
-/* Flags to set Boolean values */
-#define SPOE_DATA_FL_FALSE 0x00
-#define SPOE_DATA_FL_TRUE 0x10
/* All possible states for a SPOE context */
enum spoe_ctx_state {
SPOE_APPCTX_ST_END,
};
-/* All supported SPOE actions */
-enum spoe_action_type {
- SPOE_ACT_T_SET_VAR = 1,
- SPOE_ACT_T_UNSET_VAR,
- SPOE_ACT_TYPES,
-};
-
/* All supported SPOE events */
enum spoe_event {
SPOE_EV_NONE = 0,
SPOE_CTX_ERRS,
};
-/* Errors triggered by SPOE applet */
-enum spoe_frame_error {
- SPOE_FRM_ERR_NONE = 0,
- SPOE_FRM_ERR_IO,
- SPOE_FRM_ERR_TOUT,
- SPOE_FRM_ERR_TOO_BIG,
- SPOE_FRM_ERR_INVALID,
- SPOE_FRM_ERR_NO_VSN,
- SPOE_FRM_ERR_NO_FRAME_SIZE,
- SPOE_FRM_ERR_NO_CAP,
- SPOE_FRM_ERR_BAD_VSN,
- SPOE_FRM_ERR_BAD_FRAME_SIZE,
- SPOE_FRM_ERR_FRAG_NOT_SUPPORTED,
- SPOE_FRM_ERR_INTERLACED_FRAMES,
- SPOE_FRM_ERR_FRAMEID_NOTFOUND,
- SPOE_FRM_ERR_RES,
- SPOE_FRM_ERR_UNKNOWN = 99,
- SPOE_FRM_ERRS,
-};
-
-/* Scopes used for variables set by agents. It is a way to be agnotic to vars
- * scope. */
-enum spoe_vars_scope {
- SPOE_SCOPE_PROC = 0, /* <=> SCOPE_PROC */
- SPOE_SCOPE_SESS, /* <=> SCOPE_SESS */
- SPOE_SCOPE_TXN, /* <=> SCOPE_TXN */
- SPOE_SCOPE_REQ, /* <=> SCOPE_REQ */
- SPOE_SCOPE_RES, /* <=> SCOPE_RES */
-};
-
-/* Frame Types sent by HAProxy and by agents */
-enum spoe_frame_type {
- SPOE_FRM_T_UNSET = 0,
-
- /* Frames sent by HAProxy */
- SPOE_FRM_T_HAPROXY_HELLO = 1,
- SPOE_FRM_T_HAPROXY_DISCON,
- SPOE_FRM_T_HAPROXY_NOTIFY,
-
- /* Frames sent by the agents */
- SPOE_FRM_T_AGENT_HELLO = 101,
- SPOE_FRM_T_AGENT_DISCON,
- SPOE_FRM_T_AGENT_ACK
-};
-
-/* All supported data types */
-enum spoe_data_type {
- SPOE_DATA_T_NULL = 0,
- SPOE_DATA_T_BOOL,
- SPOE_DATA_T_INT32,
- SPOE_DATA_T_UINT32,
- SPOE_DATA_T_INT64,
- SPOE_DATA_T_UINT64,
- SPOE_DATA_T_IPV4,
- SPOE_DATA_T_IPV6,
- SPOE_DATA_T_STR,
- SPOE_DATA_T_BIN,
- SPOE_DATA_TYPES
-};
-
-
/* Describe an argument that will be linked to a message. It is a sample fetch,
* with an optional name. */
struct spoe_arg {
#include <haproxy/vars.h>
-/* Reserved 4 bytes to the frame size. So a frame and its size can be written
- * together in a buffer */
-#define MAX_FRAME_SIZE global.tune.bufsize - 4
-
-/* The minimum size for a frame */
-#define MIN_FRAME_SIZE 256
-
-/* Reserved for the metadata and the frame type.
- * So <MAX_FRAME_SIZE> - <FRAME_HDR_SIZE> is the maximum payload size */
-#define FRAME_HDR_SIZE 32
-
/* Helper to get SPOE ctx inside an appctx */
#define SPOE_APPCTX(appctx) ((struct spoe_appctx *)((appctx)->svcctx))
free(agent);
}
-static const char *spoe_frm_err_reasons[SPOE_FRM_ERRS] = {
- [SPOE_FRM_ERR_NONE] = "normal",
- [SPOE_FRM_ERR_IO] = "I/O error",
- [SPOE_FRM_ERR_TOUT] = "a timeout occurred",
- [SPOE_FRM_ERR_TOO_BIG] = "frame is too big",
- [SPOE_FRM_ERR_INVALID] = "invalid frame received",
- [SPOE_FRM_ERR_NO_VSN] = "version value not found",
- [SPOE_FRM_ERR_NO_FRAME_SIZE] = "max-frame-size value not found",
- [SPOE_FRM_ERR_NO_CAP] = "capabilities value not found",
- [SPOE_FRM_ERR_BAD_VSN] = "unsupported version",
- [SPOE_FRM_ERR_BAD_FRAME_SIZE] = "max-frame-size too big or too small",
- [SPOE_FRM_ERR_FRAG_NOT_SUPPORTED] = "fragmentation not supported",
- [SPOE_FRM_ERR_INTERLACED_FRAMES] = "invalid interlaced frames",
- [SPOE_FRM_ERR_FRAMEID_NOTFOUND] = "frame-id not found",
- [SPOE_FRM_ERR_RES] = "resource allocation error",
- [SPOE_FRM_ERR_UNKNOWN] = "an unknown error occurred",
+static const char *spoe_frm_err_reasons[SPOP_ERR_ENTRIES] = {
+ [SPOP_ERR_NONE] = "normal",
+ [SPOP_ERR_IO] = "I/O error",
+ [SPOP_ERR_TOUT] = "a timeout occurred",
+ [SPOP_ERR_TOO_BIG] = "frame is too big",
+ [SPOP_ERR_INVALID] = "invalid frame received",
+ [SPOP_ERR_NO_VSN] = "version value not found",
+ [SPOP_ERR_NO_FRAME_SIZE] = "max-frame-size value not found",
+ [SPOP_ERR_NO_CAP] = "capabilities value not found",
+ [SPOP_ERR_BAD_VSN] = "unsupported version",
+ [SPOP_ERR_BAD_FRAME_SIZE] = "max-frame-size too big or too small",
+ [SPOP_ERR_FRAG_NOT_SUPPORTED] = "fragmentation not supported",
+ [SPOP_ERR_INTERLACED_FRAMES] = "invalid interlaced frames",
+ [SPOP_ERR_FRAMEID_NOTFOUND] = "frame-id not found",
+ [SPOP_ERR_RES] = "resource allocation error",
+ [SPOP_ERR_UNKNOWN] = "an unknown error occurred",
};
static const char *spoe_event_str[SPOE_EV_EVENTS] = {
/* Predefined key used in HELLO/DISCONNECT frames */
#define SUPPORTED_VERSIONS_KEY "supported-versions"
#define VERSION_KEY "version"
-#define MAX_FRAME_SIZE_KEY "max-frame-size"
+#define SPOP_MAX_FRAME_SIZE_KEY "max-frame-size"
#define CAPABILITIES_KEY "capabilities"
#define ENGINE_ID_KEY "engine-id"
#define HEALTHCHECK_KEY "healthcheck"
struct buffer *chk;
struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
char *p, *end;
- unsigned int flags = SPOE_FRM_FL_FIN;
+ unsigned int flags = SPOP_FRM_FL_FIN;
size_t sz;
p = frame;
end = frame+size;
/* Set Frame type */
- *p++ = SPOE_FRM_T_HAPROXY_HELLO;
+ *p++ = SPOP_FRM_T_HAPROXY_HELLO;
/* Set flags */
flags = htonl(flags);
if (spoe_encode_buffer(SUPPORTED_VERSIONS_KEY, sz, &p, end) == -1)
goto too_big;
- *p++ = SPOE_DATA_T_STR;
+ *p++ = SPOP_DATA_T_STR;
sz = SLEN(SUPPORTED_VERSIONS_VAL);
if (spoe_encode_buffer(SUPPORTED_VERSIONS_VAL, sz, &p, end) == -1)
goto too_big;
/* "max-fram-size" K/V item */
- sz = SLEN(MAX_FRAME_SIZE_KEY);
- if (spoe_encode_buffer(MAX_FRAME_SIZE_KEY, sz, &p, end) == -1)
+ sz = SLEN(SPOP_MAX_FRAME_SIZE_KEY);
+ if (spoe_encode_buffer(SPOP_MAX_FRAME_SIZE_KEY, sz, &p, end) == -1)
goto too_big;
- *p++ = SPOE_DATA_T_UINT32;
+ *p++ = SPOP_DATA_T_UINT32;
if (encode_varint(SPOE_APPCTX(appctx)->max_frame_size, &p, end) == -1)
goto too_big;
if (spoe_encode_buffer(CAPABILITIES_KEY, sz, &p, end) == -1)
goto too_big;
- *p++ = SPOE_DATA_T_STR;
+ *p++ = SPOP_DATA_T_STR;
chk = get_trash_chunk();
if (agent != NULL && (agent->flags & SPOE_FL_PIPELINING)) {
memcpy(chk->area, "pipelining", 10);
if (spoe_encode_buffer(ENGINE_ID_KEY, sz, &p, end) == -1)
goto too_big;
- *p++ = SPOE_DATA_T_STR;
+ *p++ = SPOP_DATA_T_STR;
sz = strlen(agent->engine_id);
if (spoe_encode_buffer(agent->engine_id, sz, &p, end) == -1)
goto too_big;
return (p - frame);
too_big:
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_TOO_BIG;
return 0;
}
{
const char *reason;
char *p, *end;
- unsigned int flags = SPOE_FRM_FL_FIN;
+ unsigned int flags = SPOP_FRM_FL_FIN;
size_t sz;
p = frame;
end = frame+size;
/* Set Frame type */
- *p++ = SPOE_FRM_T_HAPROXY_DISCON;
+ *p++ = SPOP_FRM_T_HAPROXY_DISCON;
/* Set flags */
flags = htonl(flags);
/* No stream-id and frame-id for DISCONNECT frames */
*p++ = 0; *p++ = 0;
- if (SPOE_APPCTX(appctx)->status_code >= SPOE_FRM_ERRS)
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
+ if (SPOE_APPCTX(appctx)->status_code >= SPOP_ERR_ENTRIES)
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_UNKNOWN;
/* There are 2 mandatory items: "status-code" and "message" */
if (spoe_encode_buffer(STATUS_CODE_KEY, sz, &p, end) == -1)
goto too_big;
- *p++ = SPOE_DATA_T_UINT32;
+ *p++ = SPOP_DATA_T_UINT32;
if (encode_varint(SPOE_APPCTX(appctx)->status_code, &p, end) == -1)
goto too_big;
/*Get the message corresponding to the status code */
reason = spoe_frm_err_reasons[SPOE_APPCTX(appctx)->status_code];
- *p++ = SPOE_DATA_T_STR;
+ *p++ = SPOP_DATA_T_STR;
sz = strlen(reason);
if (spoe_encode_buffer(reason, sz, &p, end) == -1)
goto too_big;
return (p - frame);
too_big:
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_TOO_BIG;
return 0;
}
{
char *p, *end;
unsigned int stream_id, frame_id;
- unsigned int flags = SPOE_FRM_FL_FIN;
+ unsigned int flags = SPOP_FRM_FL_FIN;
size_t sz;
p = frame;
frame_id = SPOE_APPCTX(appctx)->spoe_ctx->frame_id;
/* Set Frame type */
- *p++ = SPOE_FRM_T_HAPROXY_NOTIFY;
+ *p++ = SPOP_FRM_T_HAPROXY_NOTIFY;
/* Set flags */
flags = htonl(flags);
return (p - frame);
too_big:
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_TOO_BIG;
return 0;
}
end = frame + size;
/* Check frame type */
- if (*p++ != SPOE_FRM_T_AGENT_HELLO) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ if (*p++ != SPOP_FRM_T_AGENT_HELLO) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
if (size < 7 /* TYPE + METADATA */) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
p += 4;
/* Fragmentation is not supported for HELLO frame */
- if (!(flags & SPOE_FRM_FL_FIN)) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
+ if (!(flags & SPOP_FRM_FL_FIN)) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_FRAG_NOT_SUPPORTED;
return -1;
}
/* stream-id and frame-id must be cleared */
if (*p != 0 || *(p+1) != 0) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
p += 2;
/* Decode the item key */
ret = spoe_decode_buffer(&p, end, &str, &sz);
if (ret == -1 || !sz) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
int i, type = *p++;
/* The value must be a string */
- if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ if ((type & SPOP_DATA_T_MASK) != SPOP_DATA_T_STR) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
vsn = spoe_str_to_vsn(str, sz);
if (vsn == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_BAD_VSN;
return -1;
}
for (i = 0; supported_versions[i].str != NULL; ++i) {
break;
}
if (supported_versions[i].str == NULL) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_VSN;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_BAD_VSN;
return -1;
}
}
/* Check "max-frame-size" K/V item */
- else if (sz >= strlen(MAX_FRAME_SIZE_KEY) && !memcmp(str, MAX_FRAME_SIZE_KEY, strlen(MAX_FRAME_SIZE_KEY))) {
+ else if (sz >= strlen(SPOP_MAX_FRAME_SIZE_KEY) && !memcmp(str, SPOP_MAX_FRAME_SIZE_KEY, strlen(SPOP_MAX_FRAME_SIZE_KEY))) {
int type = *p++;
/* The value must be integer */
- if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
- (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
- (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
- (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ if ((type & SPOP_DATA_T_MASK) != SPOP_DATA_T_INT32 &&
+ (type & SPOP_DATA_T_MASK) != SPOP_DATA_T_INT64 &&
+ (type & SPOP_DATA_T_MASK) != SPOP_DATA_T_UINT32 &&
+ (type & SPOP_DATA_T_MASK) != SPOP_DATA_T_UINT64) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
if (decode_varint(&p, end, &sz) == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
- if (sz < MIN_FRAME_SIZE ||
+ if (sz < SPOP_MIN_FRAME_SIZE ||
sz > SPOE_APPCTX(appctx)->max_frame_size) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_BAD_FRAME_SIZE;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_BAD_FRAME_SIZE;
return -1;
}
max_frame_size = sz;
int type = *p++;
/* The value must be a string */
- if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ if ((type & SPOP_DATA_T_MASK) != SPOP_DATA_T_STR) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
if (spoe_decode_buffer(&p, end, &str, &sz) == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
else {
/* Silently ignore unknown item */
if (spoe_skip_data(&p, end) == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
}
/* Final checks */
if (!vsn) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_VSN;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_NO_VSN;
return -1;
}
if (!max_frame_size) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NO_FRAME_SIZE;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_NO_FRAME_SIZE;
return -1;
}
if (!agent)
end = frame + size;
/* Check frame type */
- if (*p++ != SPOE_FRM_T_AGENT_DISCON) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ if (*p++ != SPOP_FRM_T_AGENT_DISCON) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
if (size < 7 /* TYPE + METADATA */) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
p += 4;
/* Fragmentation is not supported for DISCONNECT frame */
- if (!(flags & SPOE_FRM_FL_FIN)) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
+ if (!(flags & SPOP_FRM_FL_FIN)) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_FRAG_NOT_SUPPORTED;
return -1;
}
/* stream-id and frame-id must be cleared */
if (*p != 0 || *(p+1) != 0) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
p += 2;
/* Decode the item key */
ret = spoe_decode_buffer(&p, end, &str, &sz);
if (ret == -1 || !sz) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
int type = *p++;
/* The value must be an integer */
- if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT32 &&
- (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_INT64 &&
- (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT32 &&
- (type & SPOE_DATA_T_MASK) != SPOE_DATA_T_UINT64) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ if ((type & SPOP_DATA_T_MASK) != SPOP_DATA_T_INT32 &&
+ (type & SPOP_DATA_T_MASK) != SPOP_DATA_T_INT64 &&
+ (type & SPOP_DATA_T_MASK) != SPOP_DATA_T_UINT32 &&
+ (type & SPOP_DATA_T_MASK) != SPOP_DATA_T_UINT64) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
if (decode_varint(&p, end, &sz) == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
SPOE_APPCTX(appctx)->status_code = sz;
int type = *p++;
/* The value must be a string */
- if ((type & SPOE_DATA_T_MASK) != SPOE_DATA_T_STR) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ if ((type & SPOP_DATA_T_MASK) != SPOP_DATA_T_STR) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
ret = spoe_decode_buffer(&p, end, &str, &sz);
if (ret == -1 || sz > 255) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
}
else {
/* Silently ignore unknown item */
if (spoe_skip_data(&p, end) == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return 0;
}
}
end = frame + size;
/* Check frame type */
- if (*p++ != SPOE_FRM_T_AGENT_ACK) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ if (*p++ != SPOP_FRM_T_AGENT_ACK) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return -1;
}
if (size < 7 /* TYPE + METADATA */) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return -1;
}
p += 4;
/* Fragmentation is not supported for now */
- if (!(flags & SPOE_FRM_FL_FIN)) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAG_NOT_SUPPORTED;
+ if (!(flags & SPOP_FRM_FL_FIN)) {
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_FRAG_NOT_SUPPORTED;
return -1;
}
/* Get the stream-id and the frame-id */
if (decode_varint(&p, end, &stream_id) == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return -1;
}
if (decode_varint(&p, end, &frame_id) == -1) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return -1;
}
goto found;
/* No Stream found, ignore the frame */
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_FRAMEID_NOTFOUND;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_FRAMEID_NOTFOUND;
return -1;
found:
{
struct appctx appctx;
struct spoe_appctx spoe_appctx;
- char *frame, *end, buf[MAX_FRAME_SIZE+4];
+ char *frame, *end, buf[SPOP_MAX_FRAME_SIZE+4];
size_t sz;
int ret;
memset(buf, 0, sizeof(buf));
appctx.svcctx = &spoe_appctx;
- SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
+ SPOE_APPCTX(&appctx)->max_frame_size = SPOP_MAX_FRAME_SIZE;
frame = buf+4; /* Reserved the 4 first bytes for the frame size */
- end = frame + MAX_FRAME_SIZE;
+ end = frame + SPOP_MAX_FRAME_SIZE;
- ret = spoe_prepare_hahello_frame(&appctx, frame, MAX_FRAME_SIZE);
+ ret = spoe_prepare_hahello_frame(&appctx, frame, SPOP_MAX_FRAME_SIZE);
if (ret <= 0)
return -1;
frame += ret;
sz = SLEN(HEALTHCHECK_KEY);
if (spoe_encode_buffer(HEALTHCHECK_KEY, sz, &frame, end) == -1)
return -1;
- *frame++ = (SPOE_DATA_T_BOOL | SPOE_DATA_FL_TRUE);
+ *frame++ = (SPOP_DATA_T_BOOL | SPOP_DATA_FL_TRUE);
*len = frame - buf;
sz = htonl(*len - 4);
memset(&spoe_appctx, 0, sizeof(spoe_appctx));
appctx.svcctx = &spoe_appctx;
- SPOE_APPCTX(&appctx)->max_frame_size = MAX_FRAME_SIZE;
+ SPOE_APPCTX(&appctx)->max_frame_size = SPOP_MAX_FRAME_SIZE;
- if (*frame == SPOE_FRM_T_AGENT_DISCON) {
+ if (*frame == SPOP_FRM_T_AGENT_DISCON) {
spoe_handle_agentdiscon_frame(&appctx, frame, size);
goto error;
}
return 0;
error:
- if (SPOE_APPCTX(&appctx)->status_code >= SPOE_FRM_ERRS)
- SPOE_APPCTX(&appctx)->status_code = SPOE_FRM_ERR_UNKNOWN;
+ if (SPOE_APPCTX(&appctx)->status_code >= SPOP_ERR_ENTRIES)
+ SPOE_APPCTX(&appctx)->status_code = SPOP_ERR_UNKNOWN;
strncpy(err, spoe_frm_err_reasons[SPOE_APPCTX(&appctx)->status_code], errlen);
return -1;
}
if (ret > 0) {
framesz = ntohl(netint);
if (framesz < 7) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_INVALID;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_INVALID;
return -1;
}
if (framesz > SPOE_APPCTX(appctx)->max_frame_size) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOO_BIG;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_TOO_BIG;
return -1;
}
ret = co_getblk(sc_oc(sc), buf, framesz, 4);
if (ret == 0) {
return 1; /* retry */
}
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_IO;
return -1; /* error */
}
return framesz;
/* Shutdown the server connection, if needed */
if (appctx->st0 != SPOE_APPCTX_ST_END) {
appctx->st0 = SPOE_APPCTX_ST_END;
- if (spoe_appctx->status_code == SPOE_FRM_ERR_NONE)
- spoe_appctx->status_code = SPOE_FRM_ERR_IO;
+ if (spoe_appctx->status_code == SPOP_ERR_NONE)
+ spoe_appctx->status_code = SPOP_ERR_IO;
}
if (spoe_appctx->spoe_ctx) {
}
if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_TOUT;
goto exit;
}
int ret;
if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_TOUT;
goto exit;
}
ret = spoe_recv_frame(appctx, frame,
SPOE_APPCTX(appctx)->max_frame_size);
if (ret > 1) {
- if (*frame == SPOE_FRM_T_AGENT_DISCON) {
+ if (*frame == SPOP_FRM_T_AGENT_DISCON) {
appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
goto next;
}
ret = spoe_recv_frame(appctx, frame,
SPOE_APPCTX(appctx)->max_frame_size);
if (ret > 1) {
- if (*frame == SPOE_FRM_T_AGENT_DISCON) {
+ if (*frame == SPOP_FRM_T_AGENT_DISCON) {
appctx->st0 = SPOE_APPCTX_ST_DISCONNECTING;
ret = -1;
goto end;
int ret;
if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) {
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_TOUT;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_TOUT;
goto exit;
}
return;
}
- SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_NONE;
+ SPOE_APPCTX(appctx)->status_code = SPOP_ERR_NONE;
if (!SPOE_APPCTX(appctx)->spoe_ctx) {
if (appctx->st0 == SPOE_APPCTX_ST_CONNECT)
appctx->st0 = SPOE_APPCTX_ST_EXIT;
case SPOE_APPCTX_ST_EXIT:
appctx->st0 = SPOE_APPCTX_ST_END;
se_fl_set(appctx->sedesc, SE_FL_EOS);
- if (SPOE_APPCTX(appctx)->status_code != SPOE_FRM_ERR_NONE)
+ if (SPOE_APPCTX(appctx)->status_code != SPOP_ERR_NONE)
se_fl_set(appctx->sedesc, SE_FL_ERROR);
else
se_fl_set(appctx->sedesc, SE_FL_EOI);
spoe_appctx->version = 0;
spoe_appctx->max_frame_size = agent->max_frame_size;
spoe_appctx->flags = 0;
- spoe_appctx->status_code = SPOE_FRM_ERR_NONE;
+ spoe_appctx->status_code = SPOP_ERR_NONE;
spoe_appctx->buffer = BUF_NULL;
char *p, *end;
p = b_head(&ctx->buffer);
- end = p + agent->max_frame_size - FRAME_HDR_SIZE;
+ end = p + agent->max_frame_size - SPOP_FRAME_HDR_SIZE;
if (type == SPOE_MSGS_BY_EVENT) { /* Loop on messages by event */
list_for_each_entry(msg, messages, by_evt) {
goto skip;
switch (*p++) {
- case SPOE_SCOPE_PROC: scope = "proc"; break;
- case SPOE_SCOPE_SESS: scope = "sess"; break;
- case SPOE_SCOPE_TXN : scope = "txn"; break;
- case SPOE_SCOPE_REQ : scope = "req"; break;
- case SPOE_SCOPE_RES : scope = "res"; break;
+ case SPOP_SCOPE_PROC: scope = "proc"; break;
+ case SPOP_SCOPE_SESS: scope = "sess"; break;
+ case SPOP_SCOPE_TXN : scope = "txn"; break;
+ case SPOP_SCOPE_REQ : scope = "req"; break;
+ case SPOP_SCOPE_RES : scope = "res"; break;
default: goto skip;
}
goto skip;
switch (*p++) {
- case SPOE_SCOPE_PROC: scope = "proc"; break;
- case SPOE_SCOPE_SESS: scope = "sess"; break;
- case SPOE_SCOPE_TXN : scope = "txn"; break;
- case SPOE_SCOPE_REQ : scope = "req"; break;
- case SPOE_SCOPE_RES : scope = "res"; break;
+ case SPOP_SCOPE_PROC: scope = "proc"; break;
+ case SPOP_SCOPE_SESS: scope = "sess"; break;
+ case SPOP_SCOPE_TXN : scope = "txn"; break;
+ case SPOP_SCOPE_REQ : scope = "req"; break;
+ case SPOP_SCOPE_RES : scope = "res"; break;
default: goto skip;
}
type = *p++;
switch (type) {
- case SPOE_ACT_T_SET_VAR:
+ case SPOP_ACT_T_SET_VAR:
ret = spoe_decode_action_set_var(s, ctx, &p, end, dir);
if (!ret)
goto skip;
break;
- case SPOE_ACT_T_UNSET_VAR:
+ case SPOP_ACT_T_UNSET_VAR:
ret = spoe_decode_action_unset_var(s, ctx, &p, end, dir);
if (!ret)
goto skip;
curagent->var_t_process = NULL;
curagent->var_t_total = NULL;
curagent->flags = SPOE_FL_PIPELINING;
- curagent->max_frame_size = MAX_FRAME_SIZE;
+ curagent->max_frame_size = SPOP_MAX_FRAME_SIZE;
for (i = 0; i < SPOE_EV_EVENTS; ++i)
LIST_INIT(&curagent->events[i]);
if (alertif_too_many_args(1, file, linenum, args, &err_code))
goto out;
curagent->max_frame_size = atol(args[1]);
- if (curagent->max_frame_size < MIN_FRAME_SIZE ||
- curagent->max_frame_size > MAX_FRAME_SIZE) {
+ if (curagent->max_frame_size < SPOP_MIN_FRAME_SIZE ||
+ curagent->max_frame_size > SPOP_MAX_FRAME_SIZE) {
ha_alert("parsing [%s:%d] : '%s' expects a positive integer argument in the range [%d, %d].\n",
- file, linenum, args[0], MIN_FRAME_SIZE, MAX_FRAME_SIZE);
+ file, linenum, args[0], SPOP_MIN_FRAME_SIZE, SPOP_MAX_FRAME_SIZE);
err_code |= ERR_ALERT | ERR_FATAL;
goto out;
}
projects / thirdparty / haproxy.git / commitdiff
