#define FLT_NXT(flt, chn) ((flt)->next[CHN_IDX(chn)])
#define FLT_FWD(flt, chn) ((flt)->fwd[CHN_IDX(chn)])
+#define HAS_FILTERS(strm) ((strm)->strm_flt.has_filters)
+
+#define FLT_STRM_CB_IMPL_0(strm, call) \
+ do { \
+ if (HAS_FILTERS(strm)) { call; } \
+ } while (0)
+#define FLT_STRM_CB_IMPL_1(strm, call, default_ret, ...) \
+ (HAS_FILTERS(strm) ? call : default_ret)
+#define FLT_STRM_CB_IMPL_2(strm, call, default_ret, on_error) \
+ ({ \
+ int _ret; \
+ if (HAS_FILTERS(strm)) { \
+ _ret = call; \
+ if (_ret < 0) { on_error; } \
+ } \
+ else \
+ _ret = default_ret; \
+ _ret; \
+ })
+#define FLT_STRM_CB_IMPL_3(strm, call, default_ret, on_error, on_wait) \
+ ({ \
+ int _ret; \
+ if (HAS_FILTERS(strm)) { \
+ _ret = call; \
+ if (_ret < 0) { on_error; } \
+ if (!_ret) { on_wait; } \
+ } \
+ else \
+ _ret = default_ret; \
+ _ret; \
+ })
+
+#define FLT_STRM_CB_IMPL_X(strm, call, A, B, C, CB_IMPL, ...) CB_IMPL
+
+#define FLT_STRM_CB(strm, call, ...) \
+ FLT_STRM_CB_IMPL_X(strm, call, ##__VA_ARGS__, \
+ FLT_STRM_CB_IMPL_3(strm, call, ##__VA_ARGS__), \
+ FLT_STRM_CB_IMPL_2(strm, call, ##__VA_ARGS__), \
+ FLT_STRM_CB_IMPL_1(strm, call, ##__VA_ARGS__), \
+ FLT_STRM_CB_IMPL_0(strm, call))
+
+#define CALL_FILTER_ANALYZER(analyzer, strm, chn, bit) \
+ if (!HAS_FILTERS(strm) || analyzer((strm), (chn), bit)) ; else break
+
extern struct pool_head *pool2_filter;
int flt_init(struct proxy *p);
struct {
struct list filters;
struct filter *current[2]; /* 0: request, 1: response */
+ char has_filters;
} strm_flt;
struct task *task; /* the task associated with this stream */
f->conf = filter->conf;
f->is_backend_filter = is_backend;
LIST_ADDQ(&s->strm_flt.filters, &f->list);
+ s->strm_flt.has_filters = 1;
return 0;
}
LIST_INIT(&s->strm_flt.filters);
memset(s->strm_flt.current, 0, sizeof(s->strm_flt.current));
+ s->strm_flt.has_filters = 0;
list_for_each_entry(filter, &strm_fe(s)->filters, list) {
if (flt_stream_add_filter(s, filter, 0) < 0)
return -1;
pool_free2(pool2_filter, filter);
}
}
+ if (LIST_ISEMPTY(&s->strm_flt.filters))
+ s->strm_flt.has_filters = 0;
}
/*
struct filter *filter;
int ret = 1;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- goto end;
-
RESUME_FILTER_LOOP(s, msg->chn) {
if (filter->ops && filter->ops->http_headers) {
ret = filter->ops->http_headers(s, filter, msg);
{
int ret = 1;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- goto end;
-
RESUME_FILTER_LOOP(s, msg->chn) {
if (filter->ops->http_start_chunk) {
ret = filter->ops->http_start_chunk(s, filter, msg);
unsigned int buf_i;
int ret = 0;
- /* No filter, consume all available data */
- if (LIST_ISEMPTY(&s->strm_flt.filters)) {
- ret = MIN(msg->chunk_len, msg->chn->buf->i - msg->next);
- goto end;
- }
-
/* Save buffer state */
buf_i = msg->chn->buf->i;
list_for_each_entry(filter, &s->strm_flt.filters, list) {
}
/* Restore the original buffer state */
msg->chn->buf->i = buf_i;
- end:
return ret;
}
{
int ret = 1;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- goto end;
-
RESUME_FILTER_LOOP(s, msg->chn) {
if (filter->ops->http_end_chunk) {
ret = filter->ops->http_end_chunk(s, filter, msg);
{
int ret = 1;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- goto end;
-
RESUME_FILTER_LOOP(s, msg->chn) {
if (filter->ops->http_last_chunk) {
ret = filter->ops->http_last_chunk(s, filter, msg);
{
int ret = 1;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- goto end;
-
RESUME_FILTER_LOOP(s, msg->chn) {
if (filter->ops->http_chunk_trailers) {
ret = filter->ops->http_chunk_trailers(s, filter, msg);
{
int ret = 1;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- goto end;
-
RESUME_FILTER_LOOP(s, msg->chn) {
if (filter->ops->http_end) {
ret = filter->ops->http_end(s, filter, msg);
{
struct filter *filter;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- return;
-
list_for_each_entry(filter, &s->strm_flt.filters, list) {
if (filter->ops->http_reset)
filter->ops->http_reset(s, filter, msg);
{
struct filter *filter;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- return;
-
list_for_each_entry(filter, &s->strm_flt.filters, list) {
if (filter->ops->http_reply)
filter->ops->http_reply(s, filter, status, msg);
struct filter *filter = NULL;
int ret = len;
- /* No filter, forward all data */
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- goto end;
-
list_for_each_entry(filter, &s->strm_flt.filters, list) {
if (filter->ops->http_forward_data) {
/* Remove bytes that the current filter considered as
{
int ret = 1;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
- goto end;
-
RESUME_FILTER_LOOP(s, chn) {
if (filter->ops->channel_analyze) {
ret = filter->ops->channel_analyze(s, filter, chn, an_bit);
check_result:
ret = handle_analyzer_result(s, chn, 0, ret);
- end:
return ret;
}
static void http_server_error(struct stream *s, struct stream_interface *si,
int err, int finst, int status, const struct chunk *msg)
{
- flt_http_reply(s, status, msg);
+ FLT_STRM_CB(s, flt_http_reply(s, status, msg));
channel_auto_read(si_oc(si));
channel_abort(si_oc(si));
channel_auto_close(si_oc(si));
http_reply_and_close(struct stream *s, short status, struct chunk *msg)
{
s->txn->flags &= ~TX_WAIT_NEXT_RQ;
- flt_http_reply(s, status, msg);
+ FLT_STRM_CB(s, flt_http_reply(s, status, msg));
stream_int_retnclose(&s->si[0], msg);
}
}
memcpy(trash.str + trash.len, "\r\n\r\n", 4);
trash.len += 4;
- flt_http_reply(s, txn->status, &trash);
+ FLT_STRM_CB(s, flt_http_reply(s, txn->status, &trash));
bo_inject(res->chn, trash.str, trash.len);
/* "eat" the request */
bi_fast_delete(req->chn->buf, req->sov);
si_idle_conn(&s->si[1], &srv->idle_conns);
}
- if (LIST_ISEMPTY(&s->strm_flt.filters)) {
- s->req.analysers = strm_li(s) ? strm_li(s)->analysers : 0;
- s->res.analysers = 0;
- }
- else {
+ if (HAS_FILTERS(s)) {
s->req.analysers &= AN_FLT_END;
s->res.analysers &= AN_FLT_END;
}
+ else {
+ s->req.analysers = strm_li(s) ? strm_li(s)->analysers : 0;
+ s->res.analysers = 0;
+ }
}
struct session *sess = s->sess;
struct http_txn *txn = s->txn;
struct http_msg *msg = &s->txn->req;
- int ret, ret2;
+ int ret;
if (unlikely(msg->msg_state < HTTP_MSG_BODY))
return 0;
* decide whether to return 100, 417 or anything else in return of
* an "Expect: 100-continue" header.
*/
-
if (msg->msg_state == HTTP_MSG_BODY) {
/* we have msg->sov which points to the first byte of message
* body, and req->buf.p still points to the beginning of the
* message. We forward the headers now, as we don't need them
* anymore, and we want to flush them.
*/
- ret = flt_http_headers(s, msg);
- if (ret < 0)
- goto return_bad_req;
- if (!ret)
- return 0;
-
- ret = flt_http_forward_data(s, msg, msg->sov);
- if (ret < 0)
- goto return_bad_req;
- b_adv(req->buf, ret);
- msg->next -= ret;
- msg->sov -= ret;
+ FLT_STRM_CB(s, flt_http_headers(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_req,
+ /* on_wait */ return 0);
/* The previous analysers guarantee that the state is somewhere
* between MSG_BODY and the first MSG_DATA. So msg->sol and
if (msg->msg_state == HTTP_MSG_DATA) {
/* must still forward */
/* we may have some pending data starting at req->buf->p */
- ret = flt_http_data(s, msg);
- if (ret < 0)
- goto aborted_xfer;
- msg->next += ret;
+ ret = FLT_STRM_CB(s, flt_http_data(s, msg),
+ /* default_ret */ MIN(msg->chunk_len, req->buf->i - msg->next),
+ /* on_error */ goto aborted_xfer);
+ msg->next += ret;
msg->chunk_len -= ret;
if (msg->chunk_len) {
goto return_bad_req;
}
}
- ret = (msg->chunk_len
- ? flt_http_start_chunk(s, msg)
- : flt_http_last_chunk(s, msg));
- if (ret < 0)
- goto return_bad_req;
- if (!ret)
- goto missing_data;
+ if (msg->chunk_len)
+ FLT_STRM_CB(s, flt_http_start_chunk(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_req,
+ /* on_wait */ goto missing_data);
+ else
+ FLT_STRM_CB(s, flt_http_last_chunk(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_req,
+ /* on_wait */ goto missing_data);
msg->next += msg->sol;
msg->sol = 0;
msg->msg_state = msg->chunk_len ? HTTP_MSG_DATA : HTTP_MSG_TRAILERS;
goto return_bad_req;
}
}
- ret = flt_http_end_chunk(s, msg);
- if (ret < 0)
- goto return_bad_req;
- if (!ret)
- goto missing_data;
+ FLT_STRM_CB(s, flt_http_end_chunk(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_req,
+ /* on_wait */ goto missing_data);
msg->next += msg->sol;
msg->sol = 0;
msg->msg_state = HTTP_MSG_CHUNK_SIZE;
goto return_bad_req;
}
}
- ret2 = flt_http_chunk_trailers(s, msg);
- if (ret2 < 0)
- goto return_bad_req;
- if (!ret2)
- goto missing_data;
+ FLT_STRM_CB(s, flt_http_chunk_trailers(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_req,
+ /* on_wait */ goto missing_data);
msg->next += msg->sol;
msg->sol = 0;
if (!ret)
/* we may have some pending data starting at req->buf->p
* such as last chunk of data or trailers.
*/
- ret = flt_http_forward_data(s, msg, msg->next);
- if (ret < 0)
- goto return_bad_req;
+ ret = FLT_STRM_CB(s, flt_http_forward_data(s, msg, msg->next),
+ /* default_ret */ msg->next,
+ /* on_error */ goto return_bad_req);
b_adv(req->buf, ret);
msg->next -= ret;
if (unlikely(!(s->req.flags & CF_WROTE_DATA) || msg->sov > 0))
msg->sov -= ret;
-
if (msg->next)
goto skip_resync_states;
- ret = flt_http_end(s, msg);
- if (ret < 0)
- goto return_bad_req;
- if (!ret)
- goto skip_resync_states;
+ FLT_STRM_CB(s, flt_http_end(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_req,
+ /* on_wait */ goto skip_resync_states);
msg->msg_state = HTTP_MSG_DONE;
}
else {
missing_data:
/* we may have some pending data starting at req->buf->p */
- ret = flt_http_forward_data(s, msg, msg->next);
- if (ret < 0)
- goto return_bad_req;
+ ret = FLT_STRM_CB(s, flt_http_forward_data(s, msg, msg->next),
+ /* default_ret */ msg->next,
+ /* on_error */ goto return_bad_req);
b_adv(req->buf, ret);
msg->next -= ret;
if (unlikely(!(s->req.flags & CF_WROTE_DATA) || msg->sov > 0))
msg->sov -= ret;
- if (LIST_ISEMPTY(&s->strm_flt.filters))
+ if (!HAS_FILTERS(s))
msg->chunk_len -= channel_forward(req, msg->chunk_len);
/* stop waiting for data if the input is closed before the end */
msg->msg_state = HTTP_MSG_RPBEFORE;
txn->status = 0;
s->logs.t_data = -1; /* was not a response yet */
- flt_http_reset(s, msg);
+ FLT_STRM_CB(s, flt_http_reset(s, msg));
goto next_one;
case 200:
}
skip_header_mangling:
- if ((msg->flags & HTTP_MSGF_XFER_LEN) ||
- !LIST_ISEMPTY(&s->strm_flt.filters) ||
+ if ((msg->flags & HTTP_MSGF_XFER_LEN) || HAS_FILTERS(s) ||
(txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_TUN) {
rep->analysers &= ~AN_FLT_XFER_DATA;
rep->analysers |= AN_RES_HTTP_XFER_BODY;
* is performed at once on final states for all bytes parsed, or when leaving
* on missing data.
*/
+
int http_response_forward_body(struct stream *s, struct channel *res, int an_bit)
{
struct session *sess = s->sess;
struct http_txn *txn = s->txn;
struct http_msg *msg = &s->txn->rsp;
- int ret, ret2;
+ int ret;
if (unlikely(msg->msg_state < HTTP_MSG_BODY))
return 0;
* message. We forward the headers now, as we don't need them
* anymore, and we want to flush them.
*/
- ret = flt_http_headers(s, msg);
- if (ret < 0)
- goto return_bad_res;
- if (!ret)
- return 0;
-
- ret = flt_http_forward_data(s, msg, msg->sov);
- if (ret < 0)
- goto return_bad_res;
- b_adv(res->buf, ret);
- msg->next -= ret;
- msg->sov -= ret;
+ FLT_STRM_CB(s, flt_http_headers(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_res,
+ /* on_wait */ return 0);
/* The previous analysers guarantee that the state is somewhere
* between MSG_BODY and the first MSG_DATA. So msg->sol and
* found, so we must read the body until the server
* connection is closed. In that case, we eat data as
* they come. */
- if (!(msg->flags & HTTP_MSGF_XFER_LEN))
- msg->chunk_len = (res->buf->i - msg->next);
- ret = flt_http_data(s, msg);
- if (ret < 0)
- goto aborted_xfer;
+ if (!(msg->flags & HTTP_MSGF_XFER_LEN)) {
+ unsigned long long len = (res->buf->i - msg->next);
+ msg->chunk_len += len;
+ msg->body_len += len;
+ }
+ ret = FLT_STRM_CB(s, flt_http_data(s, msg),
+ /* default_ret */ MIN(msg->chunk_len, res->buf->i - msg->next),
+ /* on_error */ goto aborted_xfer);
msg->next += ret;
msg->chunk_len -= ret;
if (msg->chunk_len) {
goto return_bad_res;
}
}
- ret = flt_http_end_chunk(s, msg);
- if (ret < 0)
- goto return_bad_res;
- if (!ret)
- goto missing_data;
+ FLT_STRM_CB(s, flt_http_end_chunk(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_res,
+ /* on_wait */ goto missing_data);
msg->next += msg->sol;
msg->sol = 0;
msg->msg_state = HTTP_MSG_CHUNK_SIZE;
goto return_bad_res;
}
}
- ret = (msg->chunk_len
- ? flt_http_start_chunk(s, msg)
- : flt_http_last_chunk(s, msg));
- if (ret < 0)
- goto return_bad_res;
- if (!ret)
- goto missing_data;
+ if (msg->chunk_len)
+ FLT_STRM_CB(s, flt_http_start_chunk(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_res,
+ /* on_wait */ goto missing_data);
+ else
+ FLT_STRM_CB(s, flt_http_last_chunk(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_res,
+ /* on_wait */ goto missing_data);
msg->next += msg->sol;
msg->sol = 0;
msg->msg_state = msg->chunk_len ? HTTP_MSG_DATA : HTTP_MSG_TRAILERS;
goto return_bad_res;
}
}
- ret2 = flt_http_chunk_trailers(s, msg);
- if (ret2 < 0)
- goto return_bad_res;
- if (!ret2)
- goto missing_data;
+ FLT_STRM_CB(s, flt_http_chunk_trailers(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_res,
+ /* on_wait */ goto missing_data);
msg->next += msg->sol;
msg->sol = 0;
if (!ret)
/* we may have some pending data starting at res->buf->p
* such as a last chunk of data or trailers.
*/
- ret = flt_http_forward_data(s, msg, msg->next);
- if (ret < 0)
- goto return_bad_res;
+ ret = FLT_STRM_CB(s, flt_http_forward_data(s, msg, msg->next),
+ /* default_ret */ msg->next,
+ /* on_error */ goto return_bad_res);
b_adv(res->buf, ret);
msg->next -= ret;
if (msg->sov > 0)
msg->sov -= ret;
-
if (msg->next)
goto skip_resync_states;
- ret = flt_http_end(s, msg);
- if (ret < 0)
- goto return_bad_res;
- if (!ret)
- goto skip_resync_states;
+ FLT_STRM_CB(s, flt_http_end(s, msg),
+ /* default_ret */ 1,
+ /* on_error */ goto return_bad_res,
+ /* on_wait */ goto skip_resync_states);
msg->msg_state = HTTP_MSG_DONE;
/* fall through */
missing_data:
/* we may have some pending data starting at res->buf->p */
- ret = flt_http_forward_data(s, msg, msg->next);
- if (ret < 0)
- goto return_bad_res;
+ ret = FLT_STRM_CB(s, flt_http_forward_data(s, msg, msg->next),
+ /* default_ret */ msg->next,
+ /* on_error */ goto return_bad_res);
b_adv(res->buf, ret);
msg->next -= ret;
if (msg->sov > 0)
msg->sov -= ret;
-
- if (LIST_ISEMPTY(&s->strm_flt.filters))
+ if (!HAS_FILTERS(s))
msg->chunk_len -= channel_forward(res, msg->chunk_len);
if (res->flags & CF_SHUTW)
}
if (ana_list & AN_REQ_INSPECT_FE) {
- if (!flt_analyze(s, req, AN_REQ_INSPECT_FE))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_INSPECT_FE);
if (!tcp_inspect_request(s, req, AN_REQ_INSPECT_FE))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_INSPECT_FE);
}
if (ana_list & AN_REQ_WAIT_HTTP) {
- if (!flt_analyze(s, req, AN_REQ_WAIT_HTTP))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_WAIT_HTTP);
if (!http_wait_for_request(s, req, AN_REQ_WAIT_HTTP))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_WAIT_HTTP);
}
if (ana_list & AN_REQ_HTTP_BODY) {
- if (!flt_analyze(s, req, AN_REQ_HTTP_BODY))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_HTTP_BODY);
if (!http_wait_for_request_body(s, req, AN_REQ_HTTP_BODY))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_BODY);
}
if (ana_list & AN_REQ_HTTP_PROCESS_FE) {
- if (!flt_analyze(s, req, AN_REQ_HTTP_PROCESS_FE))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_HTTP_PROCESS_FE);
if (!http_process_req_common(s, req, AN_REQ_HTTP_PROCESS_FE, sess->fe))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_FE);
}
if (ana_list & AN_REQ_SWITCHING_RULES) {
- if (!flt_analyze(s, req, AN_REQ_SWITCHING_RULES))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_SWITCHING_RULES);
if (!process_switching_rules(s, req, AN_REQ_SWITCHING_RULES))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_SWITCHING_RULES);
}
- if (ana_list & AN_REQ_INSPECT_BE) {
- if (!flt_analyze(s, req, AN_REQ_INSPECT_BE))
+ if (ana_list & AN_FLT_START_BE) {
+ if (!flt_start_analyze(s, req, AN_FLT_START_BE))
break;
+ UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_FLT_START_BE);
+ }
+
+ if (ana_list & AN_REQ_INSPECT_BE) {
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_INSPECT_BE);
if (!tcp_inspect_request(s, req, AN_REQ_INSPECT_BE))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_INSPECT_BE);
}
if (ana_list & AN_REQ_HTTP_PROCESS_BE) {
- if (!flt_analyze(s, req, AN_REQ_HTTP_PROCESS_BE))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_HTTP_PROCESS_BE);
if (!http_process_req_common(s, req, AN_REQ_HTTP_PROCESS_BE, s->be))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_BE);
}
if (ana_list & AN_REQ_HTTP_TARPIT) {
- if (!flt_analyze(s, req, AN_REQ_HTTP_TARPIT))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_HTTP_TARPIT);
if (!http_process_tarpit(s, req, AN_REQ_HTTP_TARPIT))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_TARPIT);
}
if (ana_list & AN_REQ_SRV_RULES) {
- if (!flt_analyze(s, req, AN_REQ_SRV_RULES))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_SRV_RULES);
if (!process_server_rules(s, req, AN_REQ_SRV_RULES))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_SRV_RULES);
}
if (ana_list & AN_REQ_HTTP_INNER) {
- if (!flt_analyze(s, req, AN_REQ_HTTP_INNER))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_HTTP_INNER);
if (!http_process_request(s, req, AN_REQ_HTTP_INNER))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_INNER);
}
if (ana_list & AN_REQ_PRST_RDP_COOKIE) {
- if (!flt_analyze(s, req, AN_REQ_PRST_RDP_COOKIE))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_PRST_RDP_COOKIE);
if (!tcp_persist_rdp_cookie(s, req, AN_REQ_PRST_RDP_COOKIE))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_PRST_RDP_COOKIE);
}
if (ana_list & AN_REQ_STICKING_RULES) {
- if (!flt_analyze(s, req, AN_REQ_STICKING_RULES))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, req, AN_REQ_STICKING_RULES);
if (!process_sticking_rules(s, req, AN_REQ_STICKING_RULES))
break;
UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_STICKING_RULES);
}
- if (ana_list & AN_FLT_START_BE) {
- if (!flt_start_analyze(s, req, AN_FLT_START_BE))
- break;
- UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_FLT_START_BE);
- }
-
if (ana_list & AN_FLT_XFER_DATA) {
if (!flt_xfer_data(s, req, AN_FLT_XFER_DATA))
break;
UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_FLT_START_FE);
}
- if (ana_list & AN_RES_INSPECT) {
- if (!flt_analyze(s, res, AN_RES_INSPECT))
+ if (ana_list & AN_FLT_START_BE) {
+ if (!flt_start_analyze(s, res, AN_FLT_START_BE))
break;
+ UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_FLT_START_BE);
+ }
+
+ if (ana_list & AN_RES_INSPECT) {
+ CALL_FILTER_ANALYZER(flt_analyze, s, res, AN_RES_INSPECT);
if (!tcp_inspect_response(s, res, AN_RES_INSPECT))
break;
UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_INSPECT);
}
if (ana_list & AN_RES_WAIT_HTTP) {
- if (!flt_analyze(s, res, AN_RES_WAIT_HTTP))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, res, AN_RES_WAIT_HTTP);
if (!http_wait_for_response(s, res, AN_RES_WAIT_HTTP))
break;
UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_WAIT_HTTP);
}
if (ana_list & AN_RES_STORE_RULES) {
- if (!flt_analyze(s, res, AN_RES_STORE_RULES))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, res, AN_RES_STORE_RULES);
if (!process_store_rules(s, res, AN_RES_STORE_RULES))
break;
UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_STORE_RULES);
}
if (ana_list & AN_RES_HTTP_PROCESS_BE) {
- if (!flt_analyze(s, res, AN_RES_HTTP_PROCESS_BE))
- break;
+ CALL_FILTER_ANALYZER(flt_analyze, s, res, AN_RES_HTTP_PROCESS_BE);
if (!http_process_res_common(s, res, AN_RES_HTTP_PROCESS_BE, s->be))
break;
UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_HTTP_PROCESS_BE);
}
- if (ana_list & AN_FLT_START_BE) {
- if (!flt_start_analyze(s, res, AN_FLT_START_BE))
- break;
- UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_FLT_START_BE);
- }
-
if (ana_list & AN_FLT_XFER_DATA) {
if (!flt_xfer_data(s, res, AN_FLT_XFER_DATA))
break;
projects / thirdparty / haproxy.git / commitdiff
