MEDIUM: stream-int: Move SI err_type in the stream

Only the server side is concerned by the stream-interface error type. It is
useless to have an err_type field on the client side. So, it is now move to
the stream. SI_ET_* are renames STRM_ET_* and moved in stream-t.h header
file.

diff --git a/dev/flags/flags.c b/dev/flags/flags.c
index 0138f4f08ba929d1640a1f62b737a35ac08b43ab..4081082435aeb706cf69f4fbcd6ac9c302a28f60 100644 (file)
--- a/dev/flags/flags.c
+++ b/dev/flags/flags.c
@@ -15,7 +15,7 @@
 #define SHOW_AS_CONN  0x00000004
 #define SHOW_AS_CS    0x00000008
 #define SHOW_AS_SI    0x00000010
-#define SHOW_AS_SIET  0x00000020
+#define SHOW_AS_SET   0x00000020
 #define SHOW_AS_STRM  0x00000040
 #define SHOW_AS_TASK  0x00000080
 #define SHOW_AS_TXN   0x00000100
@@ -233,25 +233,25 @@ void show_cs_flags(unsigned int f)
        putchar('\n');
 }
 
-void show_si_et(unsigned int f)
+void show_strm_et(unsigned int f)
 {
-       printf("si->et      = ");
+       printf("strm->et    = ");
        if (!f) {
-               printf("SI_ET_NONE\n");
+               printf("STRM_ET_NONE\n");
                return;
        }
 
-       SHOW_FLAG(f, SI_ET_QUEUE_TO);
-       SHOW_FLAG(f, SI_ET_QUEUE_ERR);
-       SHOW_FLAG(f, SI_ET_QUEUE_ABRT);
-       SHOW_FLAG(f, SI_ET_CONN_TO);
-       SHOW_FLAG(f, SI_ET_CONN_ERR);
-       SHOW_FLAG(f, SI_ET_CONN_ABRT);
-       SHOW_FLAG(f, SI_ET_CONN_RES);
-       SHOW_FLAG(f, SI_ET_CONN_OTHER);
-       SHOW_FLAG(f, SI_ET_DATA_TO);
-       SHOW_FLAG(f, SI_ET_DATA_ERR);
-       SHOW_FLAG(f, SI_ET_DATA_ABRT);
+       SHOW_FLAG(f, STRM_ET_QUEUE_TO);
+       SHOW_FLAG(f, STRM_ET_QUEUE_ERR);
+       SHOW_FLAG(f, STRM_ET_QUEUE_ABRT);
+       SHOW_FLAG(f, STRM_ET_CONN_TO);
+       SHOW_FLAG(f, STRM_ET_CONN_ERR);
+       SHOW_FLAG(f, STRM_ET_CONN_ABRT);
+       SHOW_FLAG(f, STRM_ET_CONN_RES);
+       SHOW_FLAG(f, STRM_ET_CONN_OTHER);
+       SHOW_FLAG(f, STRM_ET_DATA_TO);
+       SHOW_FLAG(f, STRM_ET_DATA_ERR);
+       SHOW_FLAG(f, STRM_ET_DATA_ABRT);
 
        if (f) {
                printf("EXTRA(0x%08x)", f);
@@ -503,7 +503,7 @@ int main(int argc, char **argv)
                if (show_as & SHOW_AS_CS)    show_cs_flags(flags);
                if (show_as & SHOW_AS_ENDP)  show_endp_flags(flags);
                if (show_as & SHOW_AS_SI)    show_si_flags(flags);
-               if (show_as & SHOW_AS_SIET)  show_si_et(flags);
+               if (show_as & SHOW_AS_SET)   show_strm_et(flags);
                if (show_as & SHOW_AS_STRM)  show_strm_flags(flags);
                if (show_as & SHOW_AS_TASK)  show_task_state(flags);
                if (show_as & SHOW_AS_TXN)   show_txn_flags(flags);

diff --git a/include/haproxy/cs_utils.h b/include/haproxy/cs_utils.h
index d44ea0c84543ea55bfdaf4eb6131b059b5022aa9..ae2480b4bae2b150e4d0a11b5b4f2333d1fb5ad1 100644 (file)
--- a/include/haproxy/cs_utils.h
+++ b/include/haproxy/cs_utils.h
@@ -79,8 +79,8 @@ static inline struct conn_stream *cs_opposite(struct conn_stream *cs)
 /* to be called only when in SI_ST_DIS with SI_FL_ERR */
 static inline void cs_report_error(struct conn_stream *cs)
 {
-       if (!cs->si->err_type)
-               cs->si->err_type = SI_ET_DATA_ERR;
+       if (!__cs_strm(cs)->conn_err_type)
+               __cs_strm(cs)->conn_err_type = STRM_ET_DATA_ERR;
 
        cs_oc(cs)->flags |= CF_WRITE_ERROR;
        cs_ic(cs)->flags |= CF_READ_ERROR;

diff --git a/include/haproxy/stream-t.h b/include/haproxy/stream-t.h
index 02b8789f16823a3da9d62dd4240d7afffd75043b..530a575c8ee279eb84b4b2ed40ef00e882c94822 100644 (file)
--- a/include/haproxy/stream-t.h
+++ b/include/haproxy/stream-t.h
@@ -90,6 +90,23 @@
 #define PCLI_F_PROMPT   0x10000
 #define PCLI_F_PAYLOAD  0x20000
 
+
+/* error types reported on the streams for more accurate reporting */
+enum {
+       STRM_ET_NONE       = 0x0000,  /* no error yet, leave it to zero */
+       STRM_ET_QUEUE_TO   = 0x0001,  /* queue timeout */
+       STRM_ET_QUEUE_ERR  = 0x0002,  /* queue error (eg: full) */
+       STRM_ET_QUEUE_ABRT = 0x0004,  /* aborted in queue by external cause */
+       STRM_ET_CONN_TO    = 0x0008,  /* connection timeout */
+       STRM_ET_CONN_ERR   = 0x0010,  /* connection error (eg: no server available) */
+       STRM_ET_CONN_ABRT  = 0x0020,  /* connection aborted by external cause (eg: abort) */
+       STRM_ET_CONN_RES   = 0x0040,  /* connection aborted due to lack of resources */
+       STRM_ET_CONN_OTHER = 0x0080,  /* connection aborted for other reason (eg: 500) */
+       STRM_ET_DATA_TO    = 0x0100,  /* timeout during data phase */
+       STRM_ET_DATA_ERR   = 0x0200,  /* error during data phase */
+       STRM_ET_DATA_ABRT  = 0x0400,  /* data phase aborted by external cause */
+};
+
 struct conn_stream;
 struct hlua;
 struct proxy;
@@ -143,6 +160,7 @@ struct stream {
 
        int conn_retries;               /* number of connect retries performed */
        unsigned int conn_exp;          /* wake up time for connect, queue, turn-around, ... */
+       unsigned int conn_err_type;     /* first error detected, one of STRM_ET_* */
        enum si_state prev_conn_state;  /* SI_ST*, copy of previous state of the server conn-stream */
 
        struct list list;               /* position in the thread's streams list */

diff --git a/include/haproxy/stream_interface-t.h b/include/haproxy/stream_interface-t.h
index 08c30ad2209aebdb3f9cb1f373e2fc6032633735..0f2f6adf84694e608578bd674cca234bc9b3899e 100644 (file)
--- a/include/haproxy/stream_interface-t.h
+++ b/include/haproxy/stream_interface-t.h
@@ -64,22 +64,6 @@ enum si_state_bit {
        SI_SB_ALL = SI_SB_INI|SI_SB_REQ|SI_SB_QUE|SI_SB_TAR|SI_SB_ASS|SI_SB_CON|SI_SB_CER|SI_SB_RDY|SI_SB_EST|SI_SB_DIS|SI_SB_CLO,
 };
 
-/* error types reported on the streams interface for more accurate reporting */
-enum {
-       SI_ET_NONE       = 0x0000,  /* no error yet, leave it to zero */
-       SI_ET_QUEUE_TO   = 0x0001,  /* queue timeout */
-       SI_ET_QUEUE_ERR  = 0x0002,  /* queue error (eg: full) */
-       SI_ET_QUEUE_ABRT = 0x0004,  /* aborted in queue by external cause */
-       SI_ET_CONN_TO    = 0x0008,  /* connection timeout */
-       SI_ET_CONN_ERR   = 0x0010,  /* connection error (eg: no server available) */
-       SI_ET_CONN_ABRT  = 0x0020,  /* connection aborted by external cause (eg: abort) */
-       SI_ET_CONN_RES   = 0x0040,  /* connection aborted due to lack of resources */
-       SI_ET_CONN_OTHER = 0x0080,  /* connection aborted for other reason (eg: 500) */
-       SI_ET_DATA_TO    = 0x0100,  /* timeout during data phase */
-       SI_ET_DATA_ERR   = 0x0200,  /* error during data phase */
-       SI_ET_DATA_ABRT  = 0x0400,  /* data phase aborted by external cause */
-};
-
 /* flags set after I/O (32 bit) */
 enum {
        SI_FL_NONE       = 0x00000000,  /* nothing */
@@ -117,9 +101,6 @@ struct stream_interface {
        struct conn_stream *cs; /* points to the conn-streams that owns the endpoint (connection or applet) */
        struct si_ops *ops;     /* general operations at the stream interface layer */
 
-       /* struct members below are the "remote" part, as seen from the buffer side */
-       unsigned int err_type;  /* first error detected, one of SI_ET_* */
-
        struct wait_event wait_event; /* We're in a wait list */
 };
 

diff --git a/include/haproxy/stream_interface.h b/include/haproxy/stream_interface.h
index 1b7fd13fa3868abaca6fca1fe59490b6823a441e..3576ac47da5dbff5349d24025b7e32fe5176f699 100644 (file)
--- a/include/haproxy/stream_interface.h
+++ b/include/haproxy/stream_interface.h
@@ -106,7 +106,6 @@ static inline struct stream_interface *si_opposite(struct stream_interface *si)
  */
 static inline int si_init(struct stream_interface *si)
 {
-       si->err_type       = SI_ET_NONE;
        si->flags         &= SI_FL_ISBACK;
        si->cs             = NULL;
        si->state          = SI_ST_INI;

diff --git a/src/backend.c b/src/backend.c
index 259ff482d0c517e613fc93b55afa67566d397884..00e0bdbf52ac056b5cc2f68fd1e784fa0fecf841 100644 (file)
--- a/src/backend.c
+++ b/src/backend.c
@@ -1824,8 +1824,8 @@ int srv_redispatch_connect(struct stream *s)
                        goto redispatch;
                }
 
-               if (!cs_si(s->csb)->err_type) {
-                       cs_si(s->csb)->err_type = SI_ET_QUEUE_ERR;
+               if (!s->conn_err_type) {
+                       s->conn_err_type = STRM_ET_QUEUE_ERR;
                }
 
                _HA_ATOMIC_INC(&srv->counters.failed_conns);
@@ -1834,8 +1834,8 @@ int srv_redispatch_connect(struct stream *s)
 
        case SRV_STATUS_NOSRV:
                /* note: it is guaranteed that srv == NULL here */
-               if (!cs_si(s->csb)->err_type) {
-                       cs_si(s->csb)->err_type = SI_ET_CONN_ERR;
+               if (!s->conn_err_type) {
+                       s->conn_err_type = STRM_ET_CONN_ERR;
                }
 
                _HA_ATOMIC_INC(&s->be->be_counters.failed_conns);
@@ -1849,8 +1849,8 @@ int srv_redispatch_connect(struct stream *s)
 
        case SRV_STATUS_INTERNAL:
        default:
-               if (!cs_si(s->csb)->err_type) {
-                       cs_si(s->csb)->err_type = SI_ET_CONN_OTHER;
+               if (!s->conn_err_type) {
+                       s->conn_err_type = STRM_ET_CONN_OTHER;
                }
 
                if (srv)
@@ -1902,7 +1902,7 @@ void back_try_conn_req(struct stream *s)
                 * request may be aborted instead.
                 */
                if (back_may_abort_req(req, s)) {
-                       cs->si->err_type |= SI_ET_CONN_ABRT;
+                       s->conn_err_type |= STRM_ET_CONN_ABRT;
                        DBG_TRACE_STATE("connection aborted", STRM_EV_STRM_PROC|STRM_EV_SI_ST|STRM_EV_STRM_ERR, s);
                        goto abort_connection;
                }
@@ -1924,8 +1924,8 @@ void back_try_conn_req(struct stream *s)
                 * abort, retry immediately or redispatch.
                 */
                if (conn_err == SF_ERR_INTERNAL) {
-                       if (!cs->si->err_type) {
-                               cs->si->err_type = SI_ET_CONN_OTHER;
+                       if (!s->conn_err_type) {
+                               s->conn_err_type = STRM_ET_CONN_OTHER;
                        }
 
                        if (srv)
@@ -2005,8 +2005,8 @@ void back_try_conn_req(struct stream *s)
                        si_shutr(cs->si);
                        si_shutw(cs->si);
                        req->flags |= CF_WRITE_TIMEOUT;
-                       if (!cs->si->err_type)
-                               cs->si->err_type = SI_ET_QUEUE_TO;
+                       if (!s->conn_err_type)
+                               s->conn_err_type = STRM_ET_QUEUE_TO;
                        cs->si->state = SI_ST_CLO;
                        if (s->srv_error)
                                s->srv_error(s, cs->si);
@@ -2021,7 +2021,7 @@ void back_try_conn_req(struct stream *s)
                        /* we may need to know the position in the queue for logging */
                        pendconn_cond_unlink(s->pend_pos);
 
-                       cs->si->err_type |= SI_ET_QUEUE_ABRT;
+                       s->conn_err_type |= STRM_ET_QUEUE_ABRT;
                        DBG_TRACE_STATE("abort queued connection request", STRM_EV_STRM_PROC|STRM_EV_SI_ST|STRM_EV_STRM_ERR, s);
                        goto abort_connection;
                }
@@ -2031,7 +2031,7 @@ void back_try_conn_req(struct stream *s)
        else if (cs->si->state == SI_ST_TAR) {
                /* Connection request might be aborted */
                if (back_may_abort_req(req, s)) {
-                       cs->si->err_type |= SI_ET_CONN_ABRT;
+                       s->conn_err_type |= STRM_ET_CONN_ABRT;
                        DBG_TRACE_STATE("connection aborted", STRM_EV_STRM_PROC|STRM_EV_SI_ST|STRM_EV_STRM_ERR, s);
                        goto abort_connection;
                }
@@ -2103,7 +2103,7 @@ void back_handle_st_req(struct stream *s)
                        si_shutr(cs->si);
                        si_shutw(cs->si);
                        s->req.flags |= CF_WRITE_ERROR;
-                       cs->si->err_type = SI_ET_CONN_RES;
+                       s->conn_err_type = STRM_ET_CONN_RES;
                        cs->si->state = SI_ST_CLO;
                        if (s->srv_error)
                                s->srv_error(s, cs->si);
@@ -2115,7 +2115,7 @@ void back_handle_st_req(struct stream *s)
                        s->logs.tv_request = now;
                s->logs.t_queue   = tv_ms_elapsed(&s->logs.tv_accept, &now);
                cs->si->state     = SI_ST_EST;
-               cs->si->err_type   = SI_ET_NONE;
+               s->conn_err_type  = STRM_ET_NONE;
                be_set_sess_last(s->be);
 
                DBG_TRACE_STATE("applet registered", STRM_EV_STRM_PROC|STRM_EV_SI_ST, s);
@@ -2137,8 +2137,8 @@ void back_handle_st_req(struct stream *s)
                si_shutr(cs->si);
                si_shutw(cs->si);
                s->req.flags |= CF_WRITE_ERROR;
-               if (!cs->si->err_type)
-                       cs->si->err_type = SI_ET_CONN_OTHER;
+               if (!s->conn_err_type)
+                       s->conn_err_type = STRM_ET_CONN_OTHER;
                cs->si->state = SI_ST_CLO;
                if (s->srv_error)
                        s->srv_error(s, cs->si);
@@ -2177,7 +2177,7 @@ void back_handle_st_con(struct stream *s)
             (channel_is_empty(req) || (s->be->options & PR_O_ABRT_CLOSE)))) {
                cs->flags |= CS_FL_NOLINGER;
                si_shutw(cs->si);
-               cs->si->err_type |= SI_ET_CONN_ABRT;
+               s->conn_err_type |= STRM_ET_CONN_ABRT;
                if (s->srv_error)
                        s->srv_error(s, cs->si);
                /* Note: state = SI_ST_DIS now */
@@ -2188,11 +2188,11 @@ void back_handle_st_con(struct stream *s)
  done:
        /* retryable error ? */
        if ((s->flags & SF_CONN_EXP) || (cs->endp->flags & CS_EP_ERROR)) {
-               if (!cs->si->err_type) {
+               if (!s->conn_err_type) {
                        if (cs->endp->flags & CS_EP_ERROR)
-                               cs->si->err_type = SI_ET_CONN_ERR;
+                               s->conn_err_type = STRM_ET_CONN_ERR;
                        else
-                               cs->si->err_type = SI_ET_CONN_TO;
+                               s->conn_err_type = STRM_ET_CONN_TO;
                }
 
                cs->si->state  = SI_ST_CER;
@@ -2260,8 +2260,8 @@ void back_handle_st_cer(struct stream *s)
 
        /* ensure that we have enough retries left */
        if (s->conn_retries >= s->be->conn_retries || !(s->be->retry_type & PR_RE_CONN_FAILED)) {
-               if (!cs->si->err_type) {
-                       cs->si->err_type = SI_ET_CONN_ERR;
+               if (!s->conn_err_type) {
+                       s->conn_err_type = STRM_ET_CONN_ERR;
                }
 
                if (objt_server(s->target))
@@ -2295,8 +2295,8 @@ void back_handle_st_cer(struct stream *s)
         * ST_TAR and CS_EP_ERROR and SF_CONN_EXP flags will be unset.
         */
        if (cs_reset_endp(cs) < 0) {
-               if (!cs->si->err_type)
-                       cs->si->err_type = SI_ET_CONN_OTHER;
+               if (!s->conn_err_type)
+                       s->conn_err_type = STRM_ET_CONN_OTHER;
 
                if (objt_server(s->target))
                        _HA_ATOMIC_INC(&objt_server(s->target)->counters.internal_errors);
@@ -2336,8 +2336,8 @@ void back_handle_st_cer(struct stream *s)
                if (s->be->timeout.connect && s->be->timeout.connect < delay)
                        delay = s->be->timeout.connect;
 
-               if (!cs->si->err_type)
-                       cs->si->err_type = SI_ET_CONN_ERR;
+               if (!s->conn_err_type)
+                       s->conn_err_type = STRM_ET_CONN_ERR;
 
                /* only wait when we're retrying on the same server */
                if ((cs->si->state == SI_ST_ASS ||
@@ -2393,7 +2393,7 @@ void back_handle_st_rdy(struct stream *s)
                        /* give up */
                        cs->flags |= CS_FL_NOLINGER;
                        si_shutw(cs->si);
-                       cs->si->err_type |= SI_ET_CONN_ABRT;
+                       s->conn_err_type |= STRM_ET_CONN_ABRT;
                        if (s->srv_error)
                                s->srv_error(s, cs->si);
                        DBG_TRACE_STATE("client abort during connection attempt", STRM_EV_STRM_PROC|STRM_EV_SI_ST|STRM_EV_STRM_ERR, s);
@@ -2402,8 +2402,8 @@ void back_handle_st_rdy(struct stream *s)
 
                /* retryable error ? */
                if (cs->endp->flags & CS_EP_ERROR) {
-                       if (!cs->si->err_type)
-                               cs->si->err_type = SI_ET_CONN_ERR;
+                       if (!s->conn_err_type)
+                               s->conn_err_type = STRM_ET_CONN_ERR;
                        cs->si->state = SI_ST_CER;
                        DBG_TRACE_STATE("connection failed, retry", STRM_EV_STRM_PROC|STRM_EV_SI_ST|STRM_EV_STRM_ERR, s);
                        goto end;
@@ -2414,8 +2414,8 @@ void back_handle_st_rdy(struct stream *s)
         * now take over.
         */
        DBG_TRACE_STATE("connection established", STRM_EV_STRM_PROC|STRM_EV_SI_ST, s);
-       cs->si->err_type = SI_ET_NONE;
-       cs->si->state    = SI_ST_EST;
+       s->conn_err_type = STRM_ET_NONE;
+       cs->si->state = SI_ST_EST;
 
   end:
        DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_SI_ST, s);

diff --git a/src/cli.c b/src/cli.c
index a428b691ddd65d8ddba124912fa47a683c44534c..38a7f3519f1debbff6396f01c9be020bdcf050b1 100644 (file)
--- a/src/cli.c
+++ b/src/cli.c
@@ -2756,8 +2756,8 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                if (!si_conn_ready(cs_si(s->csb))) {
                        s->srv_conn = NULL;
                        if (cs_reset_endp(s->csb) < 0) {
-                               if (!cs_si(s->csb)->err_type)
-                                       cs_si(s->csb)->err_type = SI_ET_CONN_OTHER;
+                               if (!s->conn_err_type)
+                                       s->conn_err_type = STRM_ET_CONN_OTHER;
                                if (s->srv_error)
                                        s->srv_error(s, cs_si(s->csb));
                                return 1;
@@ -2767,7 +2767,6 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                sockaddr_free(&s->csb->dst);
 
                si_set_state(cs_si(s->csb), SI_ST_INI);
-               cs_si(s->csb)->err_type = SI_ET_NONE;
                cs_si(s->csb)->flags &= SI_FL_ISBACK; /* we're in the context of process_stream */
                s->csb->flags &= CS_FL_ISBACK | CS_FL_DONT_WAKE; /* we're in the context of process_stream */
                s->req.flags &= ~(CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CONNECT|CF_WRITE_ERROR|CF_STREAMER|CF_STREAMER_FAST|CF_NEVER_WAIT|CF_WROTE_DATA);
@@ -2777,6 +2776,7 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
                s->conn_retries = 0;  /* used for logging too */
                s->conn_exp = TICK_ETERNITY;
+               s->conn_err_type = STRM_ET_NONE;
                /* reinitialise the current rule list pointer to NULL. We are sure that
                 * any rulelist match the NULL pointer.
                 */

diff --git a/src/http_ana.c b/src/http_ana.c
index c1700f2f947ff4668ee5455ebb8bd7520ee4981b..ba64b1746cea0074726a1846cbe972bc8bda3d01 100644 (file)
--- a/src/http_ana.c
+++ b/src/http_ana.c
@@ -1248,7 +1248,7 @@ static __inline int do_l7_retry(struct stream *s, struct stream_interface *si)
        res->flags &= ~(CF_READ_ERROR | CF_READ_TIMEOUT | CF_SHUTR | CF_EOI | CF_READ_NULL | CF_SHUTR_NOW);
        res->analysers &= AN_RES_FLT_END;
        si->flags &= ~SI_FL_RXBLK_SHUT;
-       si->err_type = SI_ET_NONE;
+       s->conn_err_type = STRM_ET_NONE;
        s->flags &= ~(SF_CONN_EXP | SF_ERR_MASK | SF_FINST_MASK);
        s->conn_exp = TICK_ETERNITY;
        stream_choose_redispatch(s);
@@ -4262,8 +4262,8 @@ void http_perform_server_redirect(struct stream *s, struct stream_interface *si)
        /* return without error. */
        si_shutr(si);
        si_shutw(si);
-       si->err_type = SI_ET_NONE;
-       si->state    = SI_ST_CLO;
+       s->conn_err_type = STRM_ET_NONE;
+       si->state = SI_ST_CLO;
 
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_LOCAL;
@@ -4797,7 +4797,7 @@ int http_reply_message(struct stream *s, struct http_reply *reply)
        return -1;
 }
 
-/* Return the error message corresponding to si->err_type. It is assumed
+/* Return the error message corresponding to s->conn_err_type. It is assumed
  * that the server side is closed. Note that err_type is actually a
  * bitmask, where almost only aborts may be cumulated with other
  * values. We consider that aborted operations are more important
@@ -4810,46 +4810,46 @@ int http_reply_message(struct stream *s, struct http_reply *reply)
  */
 void http_return_srv_error(struct stream *s, struct stream_interface *si)
 {
-       int err_type = si->err_type;
+       int err_type = s->conn_err_type;
 
        /* set s->txn->status for http_error_message(s) */
-       if (err_type & SI_ET_QUEUE_ABRT) {
+       if (err_type & STRM_ET_QUEUE_ABRT) {
                s->txn->status = -1;
                http_server_error(s, si, SF_ERR_CLICL, SF_FINST_Q, NULL);
        }
-       else if (err_type & SI_ET_CONN_ABRT) {
+       else if (err_type & STRM_ET_CONN_ABRT) {
                s->txn->status = -1;
                http_server_error(s, si, SF_ERR_CLICL, SF_FINST_C, NULL);
        }
-       else if (err_type & SI_ET_QUEUE_TO) {
+       else if (err_type & STRM_ET_QUEUE_TO) {
                s->txn->status = 503;
                http_server_error(s, si, SF_ERR_SRVTO, SF_FINST_Q,
                                  http_error_message(s));
        }
-       else if (err_type & SI_ET_QUEUE_ERR) {
+       else if (err_type & STRM_ET_QUEUE_ERR) {
                s->txn->status = 503;
                http_server_error(s, si, SF_ERR_SRVCL, SF_FINST_Q,
                                  http_error_message(s));
        }
-       else if (err_type & SI_ET_CONN_TO) {
+       else if (err_type & STRM_ET_CONN_TO) {
                s->txn->status = 503;
                http_server_error(s, si, SF_ERR_SRVTO, SF_FINST_C,
                                  (s->txn->flags & TX_NOT_FIRST) ? NULL :
                                  http_error_message(s));
        }
-       else if (err_type & SI_ET_CONN_ERR) {
+       else if (err_type & STRM_ET_CONN_ERR) {
                s->txn->status = 503;
                http_server_error(s, si, SF_ERR_SRVCL, SF_FINST_C,
                                  (s->flags & SF_SRV_REUSED) ? NULL :
                                  http_error_message(s));
        }
-       else if (err_type & SI_ET_CONN_RES) {
+       else if (err_type & STRM_ET_CONN_RES) {
                s->txn->status = 503;
                http_server_error(s, si, SF_ERR_RESOURCE, SF_FINST_C,
                                  (s->txn->flags & TX_NOT_FIRST) ? NULL :
                                  http_error_message(s));
        }
-       else { /* SI_ET_CONN_OTHER and others */
+       else { /* STRM_ET_CONN_OTHER and others */
                s->txn->status = 500;
                http_server_error(s, si, SF_ERR_INTERNAL, SF_FINST_C,
                                  http_error_message(s));

diff --git a/src/stream.c b/src/stream.c
index 7ab4f5c14e306b1985cc30e8c5a439a6fe1d5db3..5ee4a8836740376a51b66f99c549a5829bcf681e 100644 (file)
--- a/src/stream.c
+++ b/src/stream.c
@@ -206,13 +206,12 @@ static void strm_trace(enum trace_level level, uint64_t mask, const struct trace
 
        /* If txn defined info about HTTP msgs, otherwise info about SI. */
        if (txn) {
-               chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x) txn.flags=0x%08x, http.flags=(0x%08x,0x%08x) status=%d",
-                             task, s, s->flags, txn->flags, txn->req.flags, txn->rsp.flags, txn->status);
+               chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x,0x%x) txn.flags=0x%08x, http.flags=(0x%08x,0x%08x) status=%d",
+                             task, s, s->flags, s->conn_err_type, txn->flags, txn->req.flags, txn->rsp.flags, txn->status);
        }
        else {
-               chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x) si_f=(%p,0x%08x,0x%x) si_b=(%p,0x%08x,0x%x) retries=%d",
-                             task, s, s->flags, si_f, si_f->flags, si_f->err_type,
-                             si_b, si_b->flags, si_b->err_type, s->conn_retries);
+               chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x,0x%x) si_f=(%p,0x%08x) si_b=(%p,0x%08x) retries=%d",
+                             task, s, s->flags, s->conn_err_type, si_f, si_f->flags, si_b, si_b->flags, s->conn_retries);
        }
 
        if (src->verbosity == STRM_VERB_MINIMAL)
@@ -422,6 +421,7 @@ struct stream *stream_new(struct session *sess, struct conn_stream *cs, struct b
        s->pending_events = 0;
        s->conn_retries = 0;
        s->conn_exp = TICK_ETERNITY;
+       s->conn_err_type = STRM_ET_NONE;
        s->prev_conn_state = SI_ST_INI;
        t->process = process_stream;
        t->context = s;
@@ -886,7 +886,7 @@ static void back_establish(struct stream *s)
                if (conn && conn->err_code != CO_ER_SSL_EARLY_FAILED)
                        req->flags |= CF_WRITE_ERROR;
                rep->flags |= CF_READ_ERROR;
-               si->err_type = SI_ET_DATA_ERR;
+               s->conn_err_type = STRM_ET_DATA_ERR;
                DBG_TRACE_STATE("read/write error", STRM_EV_STRM_PROC|STRM_EV_SI_ST|STRM_EV_STRM_ERR, s);
        }
 
@@ -1690,10 +1690,10 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
         */
        if (!stream_alloc_work_buffer(s)) {
                s->csf->endp->flags |= CS_EP_ERROR;
-               si_f->err_type = SI_ET_CONN_RES;
+               s->conn_err_type = STRM_ET_CONN_RES;
 
                s->csb->endp->flags |= CS_EP_ERROR;
-               si_b->err_type = SI_ET_CONN_RES;
+               s->conn_err_type = STRM_ET_CONN_RES;
 
                if (!(s->flags & SF_ERR_MASK))
                        s->flags |= SF_ERR_RESOURCE;
@@ -2621,38 +2621,38 @@ void sess_change_server(struct stream *strm, struct server *newsrv)
  */
 void default_srv_error(struct stream *s, struct stream_interface *si)
 {
-       int err_type = si->err_type;
+       int err_type = s->conn_err_type;
        int err = 0, fin = 0;
 
-       if (err_type & SI_ET_QUEUE_ABRT) {
+       if (err_type & STRM_ET_QUEUE_ABRT) {
                err = SF_ERR_CLICL;
                fin = SF_FINST_Q;
        }
-       else if (err_type & SI_ET_CONN_ABRT) {
+       else if (err_type & STRM_ET_CONN_ABRT) {
                err = SF_ERR_CLICL;
                fin = SF_FINST_C;
        }
-       else if (err_type & SI_ET_QUEUE_TO) {
+       else if (err_type & STRM_ET_QUEUE_TO) {
                err = SF_ERR_SRVTO;
                fin = SF_FINST_Q;
        }
-       else if (err_type & SI_ET_QUEUE_ERR) {
+       else if (err_type & STRM_ET_QUEUE_ERR) {
                err = SF_ERR_SRVCL;
                fin = SF_FINST_Q;
        }
-       else if (err_type & SI_ET_CONN_TO) {
+       else if (err_type & STRM_ET_CONN_TO) {
                err = SF_ERR_SRVTO;
                fin = SF_FINST_C;
        }
-       else if (err_type & SI_ET_CONN_ERR) {
+       else if (err_type & STRM_ET_CONN_ERR) {
                err = SF_ERR_SRVCL;
                fin = SF_FINST_C;
        }
-       else if (err_type & SI_ET_CONN_RES) {
+       else if (err_type & STRM_ET_CONN_RES) {
                err = SF_ERR_RESOURCE;
                fin = SF_FINST_C;
        }
-       else /* SI_ET_CONN_OTHER and others */ {
+       else /* STRM_ET_CONN_OTHER and others */ {
                err = SF_ERR_INTERNAL;
                fin = SF_FINST_C;
        }
@@ -3150,13 +3150,13 @@ static int stats_dump_full_strm_to_buffer(struct conn_stream *cs, struct stream
                }
 
                chunk_appendf(&trash,
-                            "  flags=0x%x, conn_retries=%d, conn_exp=%s srv_conn=%p, pend_pos=%p waiting=%d epoch=%#x\n",
+                            "  flags=0x%x, conn_retries=%d, conn_exp=%s conn_et=0x%03x srv_conn=%p, pend_pos=%p waiting=%d epoch=%#x\n",
                             strm->flags, strm->conn_retries,
                             strm->conn_exp ?
                                     tick_is_expired(strm->conn_exp, now_ms) ? "<PAST>" :
                                             human_time(TICKS_TO_MS(strm->conn_exp - now_ms),
                                             TICKS_TO_MS(1000)) : "<NEVER>",
-                             strm->srv_conn, strm->pend_pos,
+                            strm->conn_err_type, strm->srv_conn, strm->pend_pos,
                             LIST_INLIST(&strm->buffer_wait.list), strm->stream_epoch);
 
                chunk_appendf(&trash,
@@ -3251,22 +3251,20 @@ static int stats_dump_full_strm_to_buffer(struct conn_stream *cs, struct stream
                              strm->txn->req.flags, strm->txn->rsp.flags);
 
                chunk_appendf(&trash,
-                            "  si[0]=%p (state=%s flags=0x%02x endp0=%s:%p et=0x%03x sub=%d)\n",
+                            "  si[0]=%p (state=%s flags=0x%02x endp0=%s:%p sub=%d)\n",
                             strm->csf->si,
                             si_state_str(strm->csf->si->state),
                             strm->csf->si->flags,
                             (strm->csf->endp->flags & CS_EP_T_MUX ? "CONN" : "APPCTX"),
-                             __cs_endp_target(strm->csf),
-                             strm->csf->si->err_type, strm->csf->si->wait_event.events);
+                             __cs_endp_target(strm->csf), strm->csf->si->wait_event.events);
 
                chunk_appendf(&trash,
-                            "  si[1]=%p (state=%s flags=0x%02x endp1=%s:%p et=0x%03x sub=%d)\n",
+                            "  si[1]=%p (state=%s flags=0x%02x endp1=%s:%p sub=%d)\n",
                             strm->csb->si,
                             si_state_str(strm->csb->si->state),
                             strm->csb->si->flags,
                             (strm->csb->endp->flags & CS_EP_T_MUX ? "CONN" : "APPCTX"),
-                             __cs_endp_target(strm->csb),
-                            strm->csb->si->err_type, strm->csb->si->wait_event.events);
+                             __cs_endp_target(strm->csb), strm->csb->si->wait_event.events);
 
                csf = strm->csf;
                chunk_appendf(&trash, "  cs=%p csf=0x%08x endp=%p,0x%08x\n", csf, csf->flags, csf->endp->target, csf->endp->flags);