MEDIUM: tevt/stconn/stream: Add dedicated termination events for stream location

If it is the last patch to introduce dedicated termination events for each
location. In this one, events for the stream location are introcued. The old
enum is also removed because it is now unused.

Here, more accurate evets are added. The "intercepted" event was splitted.

diff --git a/include/haproxy/connection-t.h b/include/haproxy/connection-t.h
index 06ea0465a301d98100604885969a8ce225572b9b..73d990cb64e5e83fb281398581a4bebfafaf2a66 100644 (file)
--- a/include/haproxy/connection-t.h
+++ b/include/haproxy/connection-t.h
@@ -616,22 +616,21 @@ enum se_term_event_type {
        se_tevt_type_cancelled        = 12,
 };
 
-enum term_event_type {
-       /* Events emitted by haproxy */
-       tevt_type_shutw            =  1,
-       tevt_type_intercepted      =  2,
-       tevt_type_tout             =  3,
-
-       /* 4..9 unsued */
-
-       /* Events received by haproxy */
-       tevt_type_shutr            =  10,
-       tevt_type_rcv_err          =  11,
-       tevt_type_truncated_shutr  =  12,
-       tevt_type_truncated_rcv_err=  13,
-       tevt_type_snd_err          =  14,
-
-       /* 15 unsued */
+enum strm_term_event_type {
+       strm_tevt_type_shutw            =  1,
+       strm_tevt_type_eos              =  2,
+       strm_tevt_type_rcv_err          =  3,
+       strm_tevt_type_snd_err          =  4,
+       strm_tevt_type_truncated_eos    =  5,
+       strm_tevt_type_truncated_rcv_err=  6,
+
+       strm_tevt_type_tout             =  7,
+       strm_tevt_type_intercepted      =  8,
+
+       strm_tevt_type_proto_err        =  9,
+       strm_tevt_type_internal_err     = 10,
+       strm_tevt_type_other_err        = 11,
+       strm_tevt_type_aborted          = 12,
 };
 
 /* This structure describes a connection with its methods and data.

diff --git a/include/haproxy/stconn.h b/include/haproxy/stconn.h
index f213f6ce06f643b92877de0c44d07282476b8a78..dacf403e5a0df68f0b9cb970af1546404bac0460 100644 (file)
--- a/include/haproxy/stconn.h
+++ b/include/haproxy/stconn.h
@@ -574,7 +574,10 @@ static inline void se_report_term_evt(struct sedesc *se, enum se_term_event_type
        se->term_evts_log = tevt_report_event(se->term_evts_log, loc, type);
 }
 
+static inline void sc_report_term_evt(struct stconn *sc, enum strm_term_event_type type)
 {
+       enum term_event_loc loc = tevt_loc_strm;
+
        if (sc->flags & SC_FL_ISBACK)
                loc += 8;
        sc->term_evts_log = tevt_report_event(sc->term_evts_log, loc, type);

diff --git a/include/haproxy/stream.h b/include/haproxy/stream.h
index 4070b603afe6a4e15714ae339963406f16f53a9b..2212d6450fc38a2ca00c5931e634a26a45b7d7fa 100644 (file)
--- a/include/haproxy/stream.h
+++ b/include/haproxy/stream.h
@@ -418,9 +418,10 @@ static inline unsigned int stream_map_task_state(unsigned int state)
                0;
 }
 
-static inline void stream_report_term_evt(struct stconn *sc, enum term_event_loc loc, enum term_event_type type)
+static inline void stream_report_term_evt(struct stconn *sc, enum strm_term_event_type type)
 {
        struct stream *s = sc_strm(sc);
+       enum term_event_loc loc = tevt_loc_strm;
 
        if (!s)
                return;

diff --git a/src/http_ana.c b/src/http_ana.c
index 353333402fb942cc35605d6bedd4786e1207de56..f1ba56cc3e561d90d28ee9f157cd4cada07baad5 100644 (file)
--- a/src/http_ana.c
+++ b/src/http_ana.c
@@ -244,6 +244,7 @@ int http_wait_for_request(struct stream *s, struct channel *req, int an_bit)
                                txn->status = 503;
                                if (!(s->flags & SF_ERR_MASK))
                                        s->flags |= SF_ERR_LOCAL; /* we don't want a real error here */
+                               stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
                                goto return_prx_cond;
                        }
 
@@ -251,6 +252,7 @@ int http_wait_for_request(struct stream *s, struct channel *req, int an_bit)
                        txn->status = 200;
                        if (!(s->flags & SF_ERR_MASK))
                                s->flags |= SF_ERR_LOCAL; /* we don't want a real error here */
+                       stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
                        goto return_prx_cond;
                }
        }
@@ -343,6 +345,7 @@ int http_wait_for_request(struct stream *s, struct channel *req, int an_bit)
        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
+       stream_report_term_evt(s->scb, strm_tevt_type_internal_err);
        goto return_prx_cond;
 
  return_bad_req:
@@ -350,11 +353,10 @@ int http_wait_for_request(struct stream *s, struct channel *req, int an_bit)
        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
+       stream_report_term_evt(s->scb, strm_tevt_type_proto_err);
        /* fall through */
 
  return_prx_cond:
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
        http_set_term_flags(s);
        http_reply_and_close(s, txn->status, http_error_message(s));
 
@@ -412,6 +414,7 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
                        goto deny;
 
                case HTTP_RULE_RES_ABRT: /* abort request, response already sent. Eg: auth */
+                       stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
                        goto return_prx_cond;
 
                case HTTP_RULE_RES_DONE: /* OK, but terminate request processing (eg: redirect) */
@@ -465,8 +468,10 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
                if (verdict == HTTP_RULE_RES_DENY) /* stats http-request deny */
                        goto deny;
 
-               if (verdict == HTTP_RULE_RES_ABRT) /* stats auth / stats http-request auth */
+               if (verdict == HTTP_RULE_RES_ABRT) { /* stats auth / stats http-request auth */
+                       stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
                        goto return_prx_cond;
+               }
 
                if (verdict == HTTP_RULE_RES_BADREQ) /* failed with a bad request */
                        goto return_bad_req;
@@ -507,7 +512,7 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
                if (!http_apply_redirect_rule(rule, s, txn)) {
                        goto return_int_err;
                }
-               stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
+               stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
                goto done;
        }
 
@@ -559,6 +564,7 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
                _HA_ATOMIC_INC(&s->be->be_counters.denied_req);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->denied_req);
+       stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
        goto done_without_exp;
 
  deny: /* this request was blocked (denied) */
@@ -575,6 +581,7 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
                _HA_ATOMIC_INC(&s->be->be_counters.denied_req);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->denied_req);
+       stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
        goto return_prx_err;
 
  return_fail_rewrite:
@@ -598,6 +605,7 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
                _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
+       stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        goto return_prx_err;
 
  return_bad_req:
@@ -605,6 +613,7 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
+       stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
        /* fall through */
 
  return_prx_err:
@@ -613,8 +622,6 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
        /* fall through */
 
  return_prx_cond:
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
        http_set_term_flags(s);
        req->analysers &= AN_REQ_FLT_END;
        req->analyse_exp = TICK_ETERNITY;
@@ -750,9 +757,8 @@ int http_process_request(struct stream *s, struct channel *req, int an_bit)
                _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
+       stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
 
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
        http_set_term_flags(s);
        http_reply_and_close(s, txn->status, http_error_message(s));
 
@@ -795,7 +801,7 @@ int http_process_tarpit(struct stream *s, struct channel *req, int an_bit)
        s->logs.t_queue = ns_to_ms(now_ns - s->logs.accept_ts);
 
        // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
+       stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
        http_set_term_flags(s);
        http_reply_and_close(s, txn->status, (!(s->scf->flags & SC_FL_ERROR) ? http_error_message(s) : NULL));
 
@@ -833,6 +839,7 @@ int http_wait_for_request_body(struct stream *s, struct channel *req, int an_bit
        case HTTP_RULE_RES_ERROR:
                goto return_int_err;
        case HTTP_RULE_RES_ABRT:
+               stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
                goto return_prx_cond;
        default:
                goto return_int_err;
@@ -861,6 +868,7 @@ int http_wait_for_request_body(struct stream *s, struct channel *req, int an_bit
                _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
+       stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        goto return_prx_err;
 
  return_bad_req: /* let's centralize all bad requests */
@@ -868,6 +876,7 @@ int http_wait_for_request_body(struct stream *s, struct channel *req, int an_bit
        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
+       stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
        /* fall through */
 
  return_prx_err:
@@ -876,8 +885,6 @@ int http_wait_for_request_body(struct stream *s, struct channel *req, int an_bit
        /* fall through */
 
  return_prx_cond:
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
        http_set_term_flags(s);
 
        req->analysers &= AN_REQ_FLT_END;
@@ -1112,8 +1119,6 @@ int http_request_forward_body(struct stream *s, struct channel *req, int an_bit)
        goto return_prx_cond;
 
   return_int_err:
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
@@ -1122,16 +1127,16 @@ int http_request_forward_body(struct stream *s, struct channel *req, int an_bit)
                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
        if (objt_server(s->target))
                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.internal_errors);
+       stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        status = 500;
        COUNT_IF(1, "Internal error during request forwarding");
        goto return_prx_cond;
 
   return_bad_req:
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
+       stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
        status = 400;
        COUNT_IF(1, "Request parsing error during request forwarding");
        /* fall through */
@@ -1663,6 +1668,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
        txn->status = 500;
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
+       stream_report_term_evt(s->scb, strm_tevt_type_internal_err);
        goto return_prx_cond;
 
   return_bad_res:
@@ -1680,11 +1686,10 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
 
        txn->status = 502;
        stream_inc_http_fail_ctr(s);
+       stream_report_term_evt(s->scb, strm_tevt_type_proto_err);
        /* fall through */
 
  return_prx_cond:
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scb, tevt_loc_strm, tevt_type_intercepted);
        http_set_term_flags(s);
        http_reply_and_close(s, txn->status, http_error_message(s));
 
@@ -1785,6 +1790,7 @@ int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, s
                                goto deny;
 
                        case HTTP_RULE_RES_ABRT: /* abort request, response already sent */
+                               stream_report_term_evt(s->scb, strm_tevt_type_intercepted);
                                goto return_prx_cond;
 
                        case HTTP_RULE_RES_DONE: /* OK, but terminate request processing (eg: redirect) */
@@ -1976,6 +1982,7 @@ int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, s
                _HA_ATOMIC_INC(&sess->listener->counters->denied_resp);
        if (objt_server(s->target))
                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.denied_resp);
+       stream_report_term_evt(s->scb, strm_tevt_type_intercepted);
        goto return_prx_err;
 
  return_fail_rewrite:
@@ -1999,6 +2006,7 @@ int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, s
                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
        if (objt_server(s->target))
                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.internal_errors);
+       stream_report_term_evt(s->scb, strm_tevt_type_internal_err);
        goto return_prx_err;
 
  return_bad_res:
@@ -2010,6 +2018,7 @@ int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, s
                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
                health_adjust(__objt_server(s->target), HANA_STATUS_HTTP_RSP);
        }
+       stream_report_term_evt(s->scb, strm_tevt_type_proto_err);
        /* fall through */
 
  return_prx_err:
@@ -2019,9 +2028,6 @@ int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, s
 
  return_prx_cond:
        s->scb->flags |= SC_FL_NOLINGER;
-
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scb, tevt_loc_strm, tevt_type_intercepted);
        http_set_term_flags(s);
 
        rep->analysers &= AN_RES_FLT_END;
@@ -2264,7 +2270,7 @@ int http_response_forward_body(struct stream *s, struct channel *res, int an_bit
 
   return_int_err:
        // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scb, tevt_loc_strm, tevt_type_intercepted);
+       stream_report_term_evt(s->scb, strm_tevt_type_intercepted);
        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
        _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
        if (sess->listener && sess->listener->counters)
@@ -2274,11 +2280,12 @@ int http_response_forward_body(struct stream *s, struct channel *res, int an_bit
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
        COUNT_IF(1, "Internal error during response forwarding");
+       stream_report_term_evt(s->scb, strm_tevt_type_internal_err);
        goto return_error;
 
   return_bad_res:
        // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scb, tevt_loc_strm, tevt_type_intercepted);
+       stream_report_term_evt(s->scb, strm_tevt_type_intercepted);
        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
        if (objt_server(s->target)) {
                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
@@ -2286,6 +2293,7 @@ int http_response_forward_body(struct stream *s, struct channel *res, int an_bit
        }
        stream_inc_http_fail_ctr(s);
        COUNT_IF(1, "Response parsing error during response forwarding");
+       stream_report_term_evt(s->scb, strm_tevt_type_proto_err);
        /* fall through */
 
    return_error:

diff --git a/src/stconn.c b/src/stconn.c
index 3412c42bc87e9b7cdf3b90526c71e067cd133736..729886ddfb324c706da706792d0567e769a7be15 100644 (file)
--- a/src/stconn.c
+++ b/src/stconn.c
@@ -785,7 +785,7 @@ static void sc_app_shut_conn(struct stconn *sc)
        sc->flags |= SC_FL_SHUT_DONE;
        oc->flags |= CF_WRITE_EVENT;
        sc_set_hcto(sc);
-       sc_report_term_evt(sedesc->sc, tevt_loc_strm, tevt_type_shutw);
+       sc_report_term_evt(sc, strm_tevt_type_shutw);
 
        switch (sc->state) {
        case SC_ST_RDY:
@@ -1238,7 +1238,7 @@ static void sc_conn_eos(struct stconn *sc)
        sc->flags |= SC_FL_EOS;
        ic->flags |= CF_READ_EVENT;
        sc_ep_report_read_activity(sc);
-       sc_report_term_evt(sc, tevt_loc_strm, (sc->flags & SC_FL_EOI ? tevt_type_shutr: tevt_type_truncated_shutr));
+       sc_report_term_evt(sc, (sc->flags & SC_FL_EOI ? strm_tevt_type_eos: strm_tevt_type_truncated_eos));
        if (sc->state != SC_ST_EST)
                return;
 
@@ -1526,7 +1526,7 @@ int sc_conn_recv(struct stconn *sc)
        if (sc_ep_test(sc, SE_FL_ERROR)) {
                sc->flags |= SC_FL_ERROR;
                if (!(sc->flags & SC_FL_EOS))
-                       sc_report_term_evt(sc, tevt_loc_strm, (sc->flags & SC_FL_EOI ? tevt_type_rcv_err: tevt_type_truncated_rcv_err));
+                       sc_report_term_evt(sc, (sc->flags & SC_FL_EOI ? strm_tevt_type_rcv_err: strm_tevt_type_truncated_rcv_err));
                ret = 1;
        }
 
@@ -1752,7 +1752,7 @@ int sc_conn_send(struct stconn *sc)
        if (sc_ep_test(sc, SE_FL_ERROR | SE_FL_ERR_PENDING)) {
                oc->flags |= CF_WRITE_EVENT;
                BUG_ON(sc_ep_test(sc, SE_FL_EOS|SE_FL_ERROR|SE_FL_ERR_PENDING) == (SE_FL_EOS|SE_FL_ERR_PENDING));
-               sc_report_term_evt(sc, tevt_loc_strm, tevt_type_snd_err);
+               sc_report_term_evt(sc, strm_tevt_type_snd_err);
                if (sc_ep_test(sc, SE_FL_ERROR))
                        sc->flags |= SC_FL_ERROR;
                return 1;
@@ -1893,7 +1893,7 @@ int sc_conn_process(struct stconn *sc)
 
        if (sc_ep_test(sc, SE_FL_ERROR) && !(sc->flags & SC_FL_ERROR)) {
                if (!(sc->flags & SC_FL_EOS))
-                       sc_report_term_evt(sc, tevt_loc_strm, (sc->flags & SC_FL_EOI ? tevt_type_rcv_err: tevt_type_truncated_rcv_err));
+                       sc_report_term_evt(sc, (sc->flags & SC_FL_EOI ? strm_tevt_type_rcv_err: strm_tevt_type_truncated_rcv_err));
                sc->flags |= SC_FL_ERROR;
        }
 

diff --git a/src/stream.c b/src/stream.c
index c61c3fcb6c532ee9ff79ef14a7374f1e33d0125d..f82a858063f17b7a26fa5f40e72f49173b746b61 100644 (file)
--- a/src/stream.c
+++ b/src/stream.c
@@ -1576,25 +1576,25 @@ static void stream_handle_timeouts(struct stream *s)
        channel_check_timeout(&s->res);
 
        if (unlikely(!(s->scb->flags & SC_FL_SHUT_DONE) && (s->req.flags & CF_WRITE_TIMEOUT))) {
-               stream_report_term_evt(s->scb, tevt_loc_strm, tevt_type_tout);
+               stream_report_term_evt(s->scb, strm_tevt_type_tout);
                s->scb->flags |= SC_FL_NOLINGER;
                sc_shutdown(s->scb);
        }
 
        if (unlikely(!(s->scf->flags & (SC_FL_EOS|SC_FL_ABRT_DONE)) && (s->req.flags & CF_READ_TIMEOUT))) {
-               stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_tout);
+               stream_report_term_evt(s->scf, strm_tevt_type_tout);
                if (s->scf->flags & SC_FL_NOHALF)
                        s->scf->flags |= SC_FL_NOLINGER;
                sc_abort(s->scf);
        }
        if (unlikely(!(s->scf->flags & SC_FL_SHUT_DONE) && (s->res.flags & CF_WRITE_TIMEOUT))) {
-               stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_tout);
+               stream_report_term_evt(s->scf, strm_tevt_type_tout);
                s->scf->flags |= SC_FL_NOLINGER;
                sc_shutdown(s->scf);
        }
 
        if (unlikely(!(s->scb->flags & (SC_FL_EOS|SC_FL_ABRT_DONE)) && (s->res.flags & CF_READ_TIMEOUT))) {
-               stream_report_term_evt(s->scb, tevt_loc_strm, tevt_type_tout);
+               stream_report_term_evt(s->scb, strm_tevt_type_tout);
                if (s->scb->flags & SC_FL_NOHALF)
                        s->scb->flags |= SC_FL_NOLINGER;
                sc_abort(s->scb);

diff --git a/src/tcp_rules.c b/src/tcp_rules.c
index 8771b32e88a437cc0a2ddd414bac8a73c19b5f59..d65be42043b2a62267a8ed43d67a446aa26ed83c 100644 (file)
--- a/src/tcp_rules.c
+++ b/src/tcp_rules.c
@@ -193,6 +193,7 @@ resume_execution:
                                        s->last_entity.ptr  = rule;
                                        goto deny;
                                case ACT_RET_ABRT:
+                                       stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
                                        s->last_entity.type = STRM_ENTITY_RULE;
                                        s->last_entity.ptr  = rule;
                                        goto abort;
@@ -249,6 +250,7 @@ resume_execution:
        _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_req);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->denied_req);
+       stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
        goto reject;
 
  internal:
@@ -257,12 +259,14 @@ resume_execution:
                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
+       stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        goto reject;
 
  invalid:
        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
        if (sess->listener && sess->listener->counters)
                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
+       stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
 
  reject:
        sc_must_kill_conn(s->scf);
@@ -270,7 +274,6 @@ resume_execution:
 
  abort:
        // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scf, tevt_loc_strm, tevt_type_intercepted);
        req->analysers &= AN_REQ_FLT_END;
        s->current_rule = s->current_rule_list = NULL;
        req->analyse_exp = s->rules_exp = TICK_ETERNITY;
@@ -387,6 +390,7 @@ resume_execution:
                                        s->last_entity.ptr  = rule;
                                        goto deny;
                                case ACT_RET_ABRT:
+                                       stream_report_term_evt(s->scb, strm_tevt_type_intercepted);
                                        s->last_entity.type = STRM_ENTITY_RULE;
                                        s->last_entity.ptr  = rule;
                                        goto abort;
@@ -454,6 +458,7 @@ resume_execution:
                _HA_ATOMIC_INC(&s->sess->listener->counters->denied_resp);
        if (objt_server(s->target))
                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.denied_resp);
+       stream_report_term_evt(s->scb, strm_tevt_type_intercepted);
        goto reject;
 
  internal:
@@ -465,20 +470,20 @@ resume_execution:
                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.internal_errors);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
+       stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        goto reject;
 
  invalid:
        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
        if (objt_server(s->target))
                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
+       stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
 
  reject:
        sc_must_kill_conn(s->scb);
        stream_abort(s);
 
   abort:
-       // XXX: All errors are handled as intercepted here !
-       stream_report_term_evt(s->scb, tevt_loc_strm, tevt_type_intercepted);
        rep->analysers &= AN_RES_FLT_END;
        s->current_rule = s->current_rule_list = NULL;
        rep->analyse_exp = s->rules_exp = TICK_ETERNITY;