MEDIUM: conn-stream: Move remaning flags from CS to endpoint

All old flags CS_FL_* are now moved in the endpoint scope and renamed
CS_EP_* accordingly. It is a systematic replacement. There is no true change
except for the health-check and the endpoint reset. Here it is a bit special
because the same conn-stream is reused. Thus, we must handle endpoint
allocation errors. To do so, cs_reset_endp() has been adapted.

Thanks to this last change, it will now be possible to simplify the
multiplexer and probably the applets too. A review must also be performed to
remove some flags in the channel or the stream-interface. The HTX will
probably be simplified too. Finally, there is now some place in the
conn-stream to move info from the stream-interface.

diff --git a/addons/promex/service-prometheus.c b/addons/promex/service-prometheus.c
index 61bf4653fe8238ca80b590cdf81da4ccc61bab1f..e02da75b83cc18987877a7f55e60c31756d02574 100644 (file)
--- a/addons/promex/service-prometheus.c
+++ b/addons/promex/service-prometheus.c
@@ -1523,7 +1523,7 @@ static void promex_appctx_handle_io(struct appctx *appctx)
                                channel_add_input(res, 1);
                        }
                        res_htx->flags |= HTX_FL_EOM;
-                       si->cs->flags |= CS_FL_EOI;
+                       si->cs->endp->flags |= CS_EP_EOI;
                        res->flags |= CF_EOI;
                        appctx->st0 = PROMEX_ST_END;
                        /* fall through */

diff --git a/dev/flags/flags.c b/dev/flags/flags.c
index 08cb2e89f31247090236bf313fe8cb546e4596a5..ddfd879066d33b958827c3aeb984cd8efdb9a9ed 100644 (file)
--- a/dev/flags/flags.c
+++ b/dev/flags/flags.c
@@ -189,6 +189,12 @@ void show_endp_flags(unsigned int f)
        }
        SHOW_FLAG(f, CS_EP_KILL_CONN);
        SHOW_FLAG(f, CS_EP_WAIT_FOR_HS);
+       SHOW_FLAG(f, CS_EP_WANT_ROOM);
+       SHOW_FLAG(f, CS_EP_ERROR);
+       SHOW_FLAG(f, CS_EP_ERR_PENDING);
+       SHOW_FLAG(f, CS_EP_EOS);
+       SHOW_FLAG(f, CS_EP_EOI);
+       SHOW_FLAG(f, CS_EP_RCV_MORE);
        SHOW_FLAG(f, CS_EP_MAY_SPLICE);
        SHOW_FLAG(f, CS_EP_WEBSOCKET);
        SHOW_FLAG(f, CS_EP_NOT_FIRST);
@@ -213,12 +219,6 @@ void show_cs_flags(unsigned int f)
                printf("0\n");
                return;
        }
-       SHOW_FLAG(f, CS_FL_EOI);
-       SHOW_FLAG(f, CS_FL_EOS);
-       SHOW_FLAG(f, CS_FL_ERR_PENDING);
-       SHOW_FLAG(f, CS_FL_WANT_ROOM);
-       SHOW_FLAG(f, CS_FL_RCV_MORE);
-       SHOW_FLAG(f, CS_FL_ERROR);
 
        if (f) {
                printf("EXTRA(0x%08x)", f);

diff --git a/include/haproxy/conn_stream-t.h b/include/haproxy/conn_stream-t.h
index 842ce844379e4cb32fc4ddc617cf5d51a164e325..bde6600ca1b63b7ee1de0860216c70409f98489b 100644 (file)
--- a/include/haproxy/conn_stream-t.h
+++ b/include/haproxy/conn_stream-t.h
@@ -54,30 +54,30 @@ struct stream_interface;
        /* following flags are supposed to be set by the endpoint and read by
         * the app layer :
         */
+        /* Permanent flags */
        CS_EP_NOT_FIRST  = 0x00001000,  /* This conn-stream is not the first one for the endpoint */
        CS_EP_WEBSOCKET  = 0x00002000,  /* The endpoint uses the websocket proto */
-       CS_EP_MAY_SPLICE = 0x00004000,  /* The endpoint may use the kernel splicing to forward data to the other side (implies CS_EP_CAN_SPLICE) */
+       CS_EP_EOI        = 0x00004000,  /* end-of-input reached */
+       CS_EP_EOS        = 0x00008000,  /* End of stream delivered to data layer */
+       CS_EP_ERROR      = 0x00010000,  /* a fatal error was reported */
+       /* Transient flags */
+       CS_EP_ERR_PENDING= 0x00020000,  /* An error is pending, but there's still data to be read */
+       CS_EP_MAY_SPLICE = 0x00040000,  /* The endpoint may use the kernel splicing to forward data to the other side (implies CS_EP_CAN_SPLICE) */
+       CS_EP_RCV_MORE   = 0x00080000,  /* Endpoint may have more bytes to transfer */
+       CS_EP_WANT_ROOM  = 0x00100000,  /* More bytes to transfer, but not enough room */
 
-        /* unused: 0x00008000 */
+        /* unused: 0x00200000 ..  0x00800000 */
 
        /* following flags are supposed to be set by the app layer and read by
         * the endpoint :
         */
-       CS_EP_WAIT_FOR_HS   = 0x00010000,  /* This stream is waiting for handhskae */
-       CS_EP_KILL_CONN     = 0x00020000,  /* must kill the connection when the CS closes */
+       CS_EP_WAIT_FOR_HS   = 0x01000000,  /* This stream is waiting for handhskae */
+       CS_EP_KILL_CONN     = 0x02000000,  /* must kill the connection when the CS closes */
  };
 
 /* conn_stream flags */
 enum {
        CS_FL_NONE          = 0x00000000,  /* Just for initialization purposes */
-
-       CS_FL_ERROR         = 0x00000100,  /* a fatal error was reported */
-       CS_FL_RCV_MORE      = 0x00000200,  /* We may have more bytes to transfer */
-       CS_FL_WANT_ROOM     = 0x00000400,  /* More bytes to transfer, but not enough room */
-       CS_FL_ERR_PENDING   = 0x00000800,  /* An error is pending, but there's still data to be read */
-       CS_FL_EOS           = 0x00001000,  /* End of stream delivered to data layer */
-       /* unused: 0x00002000 */
-       CS_FL_EOI           = 0x00004000,  /* end-of-input reached */
 };
 
 /* cs_shutr() modes */

diff --git a/include/haproxy/conn_stream.h b/include/haproxy/conn_stream.h
index ca5a99c93fc564a0bb7568a7cd35ea7d1c835878..aa708c75a913d52cb24376b926f2477f94d35a3e 100644 (file)
--- a/include/haproxy/conn_stream.h
+++ b/include/haproxy/conn_stream.h
@@ -210,13 +210,13 @@ static inline void cs_drain_and_close(struct conn_stream *cs)
        cs_shutr(cs, CS_SHR_DRAIN);
 }
 
-/* sets CS_FL_ERROR or CS_FL_ERR_PENDING on the cs */
+/* sets CS_EP_ERROR or CS_EP_ERR_PENDING on the cs */
 static inline void cs_set_error(struct conn_stream *cs)
 {
-       if (cs->flags & CS_FL_EOS)
-               cs->flags |= CS_FL_ERROR;
+       if (cs->endp->flags & CS_EP_EOS)
+               cs->endp->flags |= CS_EP_ERROR;
        else
-               cs->flags |= CS_FL_ERR_PENDING;
+               cs->endp->flags |= CS_EP_ERR_PENDING;
 }
 
 /* Retrieves any valid conn_stream from this connection, preferably the first

diff --git a/src/backend.c b/src/backend.c
index f57d05d84b68c4025c0230b7a6d5d789b4ef97b1..09f10e8f0f99a88090b4bd2490b6c2fe0d0f29af 100644 (file)
--- a/src/backend.c
+++ b/src/backend.c
@@ -1743,7 +1743,7 @@ skip_reuse:
         * sockets, socket pairs, and occasionally TCP connections on the
         * loopback on a heavily loaded system.
         */
-       if ((srv_conn->flags & CO_FL_ERROR || s->csb->flags & CS_FL_ERROR))
+       if ((srv_conn->flags & CO_FL_ERROR || s->csb->endp->flags & CS_EP_ERROR))
                cs_si(s->csb)->flags |= SI_FL_ERR;
 
        /* If we had early data, and the handshake ended, then
@@ -1769,7 +1769,7 @@ skip_reuse:
         *       wake callback. Otherwise si_cs_recv()/si_cs_send() already take
         *       care of it.
         */
-       if ((s->csb->flags & CS_FL_EOI) && !(si_ic(cs_si(s->csb))->flags & CF_EOI))
+       if ((s->csb->endp->flags & CS_EP_EOI) && !(si_ic(cs_si(s->csb))->flags & CF_EOI))
                si_ic(cs_si(s->csb))->flags |= (CF_EOI|CF_READ_PARTIAL);
 
        /* catch all sync connect while the mux is not already installed */

diff --git a/src/cache.c b/src/cache.c
index 1aa1103a6b707a854e80db1b386095ff2df09913..ce6c7ea6f5cbc9d179590aa7c7fba02d5debf3b3 100644 (file)
--- a/src/cache.c
+++ b/src/cache.c
@@ -1500,7 +1500,7 @@ static void http_cache_io_handler(struct appctx *appctx)
        if (appctx->st0 == HTX_CACHE_EOM) {
                 /* no more data are expected. */
                res_htx->flags |= HTX_FL_EOM;
-               si->cs->flags |= CS_FL_EOI;
+               si->cs->endp->flags |= CS_EP_EOI;
                res->flags |= CF_EOI;
                appctx->st0 = HTX_CACHE_END;
        }

diff --git a/src/check.c b/src/check.c
index 47a53db3dc6aa718e0eef666072e60ccb05615ae..058b23322e5ee13d2ac35e19d39940df63fecf00 100644 (file)
--- a/src/check.c
+++ b/src/check.c
@@ -795,7 +795,7 @@ void chk_report_conn_err(struct check *check, int errno_bck, int expired)
                retrieve_errno_from_socket(conn);
 
        if (conn && !(conn->flags & CO_FL_ERROR) &&
-           cs && !(cs->flags & CS_FL_ERROR) && !expired)
+           cs && !(cs->endp->flags & CS_EP_ERROR) && !expired)
                return;
 
        TRACE_ENTER(CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check, 0, 0, (size_t[]){expired});
@@ -914,7 +914,7 @@ void chk_report_conn_err(struct check *check, int errno_bck, int expired)
        }
        else if (conn->flags & CO_FL_WAIT_L4_CONN) {
                /* L4 not established (yet) */
-               if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)
+               if (conn->flags & CO_FL_ERROR || cs->endp->flags & CS_EP_ERROR)
                        set_server_check_status(check, HCHK_STATUS_L4CON, err_msg);
                else if (expired)
                        set_server_check_status(check, HCHK_STATUS_L4TOUT, err_msg);
@@ -929,12 +929,12 @@ void chk_report_conn_err(struct check *check, int errno_bck, int expired)
        }
        else if (conn->flags & CO_FL_WAIT_L6_CONN) {
                /* L6 not established (yet) */
-               if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)
+               if (conn->flags & CO_FL_ERROR || cs->endp->flags & CS_EP_ERROR)
                        set_server_check_status(check, HCHK_STATUS_L6RSP, err_msg);
                else if (expired)
                        set_server_check_status(check, HCHK_STATUS_L6TOUT, err_msg);
        }
-       else if (conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR) {
+       else if (conn->flags & CO_FL_ERROR || cs->endp->flags & CS_EP_ERROR) {
                /* I/O error after connection was established and before we could diagnose */
                set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
        }
@@ -1037,7 +1037,7 @@ static int wake_srv_chk(struct conn_stream *cs)
        cs = check->cs;
        conn = cs_conn(cs);
 
-       if (unlikely(!conn || !cs || conn->flags & CO_FL_ERROR || cs->flags & CS_FL_ERROR)) {
+       if (unlikely(!conn || !cs || conn->flags & CO_FL_ERROR || cs->endp->flags & CS_EP_ERROR)) {
                /* We may get error reports bypassing the I/O handlers, typically
                 * the case when sending a pure TCP check which fails, then the I/O
                 * handlers above are not called. This is completely handled by the
@@ -1135,13 +1135,17 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
 
                check->current_step = NULL;
 
-               if (check->cs->flags & CS_FL_ERROR) {
-                       check->cs->flags &= ~CS_FL_ERROR;
+               if (!check->cs->endp) {
+                       /* CS endpoint may be NULL if a previous reset
+                        * failed. Try to allocate a new one and report a
+                        * SOCKERR if it fails.
+                        */
                        check->cs->endp = cs_endpoint_new();
-                       if (!check->cs->endp)
-                               check->cs->flags |= CS_FL_ERROR;
-                       else
-                               check->cs->endp->flags |=  CS_EP_DETACHED;
+                       if (!check->cs->endp) {
+                               set_server_check_status(check, HCHK_STATUS_SOCKERR, NULL);
+                               goto end;
+                       }
+                       check->cs->endp->flags |= CS_EP_DETACHED;
                }
                tcpcheck_main(check);
                expired = 0;
@@ -1157,7 +1161,7 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
                /* Here the connection must be defined. Otherwise the
                 * error would have already been detected
                 */
-               if ((conn && ((conn->flags & CO_FL_ERROR) || (check->cs->flags & CS_FL_ERROR))) || expired) {
+               if ((conn && ((conn->flags & CO_FL_ERROR) || (check->cs->endp->flags & CS_EP_ERROR))) || expired) {
                        TRACE_ERROR("report connection error", CHK_EV_TASK_WAKE|CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
                        chk_report_conn_err(check, 0, expired);
                }
@@ -1165,9 +1169,8 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
                        if (check->state & CHK_ST_CLOSE_CONN) {
                                TRACE_DEVEL("closing current connection", CHK_EV_TASK_WAKE|CHK_EV_HCHK_RUN, check);
                                check->state &= ~CHK_ST_CLOSE_CONN;
-                               if (cs_reset_endp(check->cs) < 0)
-                                       check->cs->flags |= CS_FL_ERROR;
                                conn = NULL;
+                               cs_reset_endp(check->cs); /* error will be handled by tcpcheck_main() */
                                tcpcheck_main(check);
                        }
                        if (check->result == CHK_RES_UNKNOWN) {
@@ -1201,12 +1204,9 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
         */
        tasklet_remove_from_tasklet_list(check->wait_list.tasklet);
 
-       if (cs_reset_endp(check->cs) < 0) {
-               /* If an error occurred at this stage, it will be fixed by the
-                * next check
-                */
-               check->cs->flags |= CS_FL_ERROR;
-       }
+       /* Force detach on error. the endpoint will be recreated on the next start */
+       if (cs_reset_endp(check->cs) < 0)
+               cs_detach_endp(check->cs);
 
        if (check->sess != NULL) {
                vars_prune(&check->vars, check->sess, NULL);
@@ -1214,6 +1214,7 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
                check->sess = NULL;
        }
 
+  end:
        if (check->server && likely(!(check->state & CHK_ST_PURGE))) {
                if (check->result == CHK_RES_FAILED) {
                        /* a failure or timeout detected */

diff --git a/src/conn_stream.c b/src/conn_stream.c
index d45eba63c11e1f687dc6ff09abfcee02c8af61fe..bb5178448090addf36309889461468e19ec087f1 100644 (file)
--- a/src/conn_stream.c
+++ b/src/conn_stream.c
@@ -222,6 +222,9 @@ int cs_attach_strm(struct conn_stream *cs, struct stream *strm)
  */
 void cs_detach_endp(struct conn_stream *cs)
 {
+       if (!cs->endp)
+               goto reset_cs;
+
        if (cs->endp->flags & CS_EP_T_MUX) {
                struct connection *conn = cs_conn(cs);
 
@@ -260,6 +263,7 @@ void cs_detach_endp(struct conn_stream *cs)
                cs->endp->flags |= CS_EP_DETACHED;
        }
 
+  reset_cs:
        /* FIXME: Rest CS for now but must be reviewed. CS flags are only
         *        connection related for now but this will evolved
         */
@@ -285,15 +289,29 @@ void cs_detach_app(struct conn_stream *cs)
 
 int cs_reset_endp(struct conn_stream *cs)
 {
+       struct cs_endpoint *new_endp;
+
        BUG_ON(!cs->app);
-       cs_detach_endp(cs);
-       if (!cs->endp) {
-               cs->endp = cs_endpoint_new();
-               if (!cs->endp) {
-                       cs->flags |= CS_FL_ERROR;
-                       return -1;
-               }
-               cs->endp->flags |= CS_EP_DETACHED;
+       if (!__cs_endp_target(cs)) {
+               /* endpoint not attached or attached to a mux with no
+                * target. Thus the endpoint will not be release but just
+                * reset
+                */
+               cs_detach_endp(cs);
+               return 0;
        }
+
+       /* allocate the new endpoint first to be able to set error if it
+        * fails */
+       new_endp = cs_endpoint_new();
+       if (!unlikely(new_endp)) {
+               cs->endp->flags |= CS_EP_ERROR;
+               return -1;
+       }
+
+       cs_detach_endp(cs);
+       BUG_ON(cs->endp);
+       cs->endp = new_endp;
+       cs->endp->flags |= CS_EP_DETACHED;
        return 0;
 }

diff --git a/src/hlua.c b/src/hlua.c
index af26aae03c7dc480e4a630d93eaeeec6ae608e30..931e741370518ec6946a3eb656e5bc55d7db0a18 100644 (file)
--- a/src/hlua.c
+++ b/src/hlua.c
@@ -9576,7 +9576,7 @@ void hlua_applet_http_fct(struct appctx *ctx)
                }
 
                res_htx->flags |= HTX_FL_EOM;
-               si->cs->flags |= CS_FL_EOI;
+               si->cs->endp->flags |= CS_EP_EOI;
                res->flags |= CF_EOI;
                strm->txn->status = ctx->ctx.hlua_apphttp.status;
                ctx->ctx.hlua_apphttp.flags |= APPLET_RSP_SENT;

diff --git a/src/http_ana.c b/src/http_ana.c
index 57bb3f1cd38720a6e3fff12faebb794d5f70a794..05b62fe02053c8788b7e5e6d04be9a1034227bf7 100644 (file)
--- a/src/http_ana.c
+++ b/src/http_ana.c
@@ -1256,7 +1256,6 @@ static __inline int do_l7_retry(struct stream *s, struct stream_interface *si)
        res->total = 0;
 
        if (cs_reset_endp(s->csb) < 0) {
-               s->csb->flags |= CS_FL_ERROR;
                if (!(s->flags & SF_ERR_MASK))
                        s->flags |= SF_ERR_INTERNAL;
                return -1;

diff --git a/src/http_client.c b/src/http_client.c
index 1e87a5033bc86726e12fd7a88400e5f40bf2d8a4..c0677368c668e4701d877f2dd88e57c23f1c7344 100644 (file)
--- a/src/http_client.c
+++ b/src/http_client.c
@@ -735,7 +735,7 @@ static void httpclient_applet_io_handler(struct appctx *appctx)
 
                                        /* if the request contains the HTX_FL_EOM, we finished the request part. */
                                        if (htx->flags & HTX_FL_EOM) {
-                                               si->cs->flags |= CS_FL_EOI;
+                                               si->cs->endp->flags |= CS_EP_EOI;
                                                req->flags |= CF_EOI;
                                                appctx->st0 = HTTPCLIENT_S_RES_STLINE;
                                        }

diff --git a/src/mux_fcgi.c b/src/mux_fcgi.c
index a74554e5534ff79985d7a7277b33ccd91922d15b..9af915dc78b096b8d6799494515d26915c4b8d1a 100644 (file)
--- a/src/mux_fcgi.c
+++ b/src/mux_fcgi.c
@@ -1011,7 +1011,7 @@ static inline void fcgi_strm_close(struct fcgi_strm *fstrm)
                if (!fstrm->id)
                        fstrm->fconn->nb_reserved--;
                if (fstrm->cs) {
-                       if (!(fstrm->cs->flags & CS_FL_EOS) && !b_data(&fstrm->rxbuf))
+                       if (!(fstrm->endp->flags & CS_EP_EOS) && !b_data(&fstrm->rxbuf))
                                fcgi_strm_notify_recv(fstrm);
                }
                fstrm->state = FCGI_SS_CLOSED;
@@ -1148,8 +1148,8 @@ static struct fcgi_strm *fcgi_conn_stream_new(struct fcgi_conn *fconn, struct co
        return NULL;
 }
 
-/* Wakes a specific stream and assign its conn_stream some CS_FL_* flags among
- * CS_FL_ERR_PENDING and CS_FL_ERROR if needed. The stream's state is
+/* Wakes a specific stream and assign its conn_stream some CS_EP_* flags among
+ * CS_EP_ERR_PENDING and CS_EP_ERROR if needed. The stream's state is
  * automatically updated accordingly. If the stream is orphaned, it is
  * destroyed.
  */
@@ -1176,9 +1176,9 @@ static void fcgi_strm_wake_one_stream(struct fcgi_strm *fstrm)
        }
 
        if ((fconn->state == FCGI_CS_CLOSED || fconn->conn->flags & CO_FL_ERROR)) {
-               fstrm->cs->flags |= CS_FL_ERR_PENDING;
-               if (fstrm->cs->flags & CS_FL_EOS)
-                       fstrm->cs->flags |= CS_FL_ERROR;
+               fstrm->endp->flags |= CS_EP_ERR_PENDING;
+               if (fstrm->endp->flags & CS_EP_EOS)
+                       fstrm->endp->flags |= CS_EP_ERROR;
 
                if (fstrm->state < FCGI_SS_ERROR) {
                        fstrm->state = FCGI_SS_ERROR;
@@ -2626,10 +2626,10 @@ static void fcgi_process_demux(struct fcgi_conn *fconn)
                     fcgi_conn_read0_pending(fconn) ||
                     fstrm->state == FCGI_SS_CLOSED ||
                     (fstrm->flags & FCGI_SF_ES_RCVD) ||
-                    (fstrm->cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING|CS_FL_EOS)))) {
+                    (fstrm->endp->flags & (CS_EP_ERROR|CS_EP_ERR_PENDING|CS_EP_EOS)))) {
                        /* we may have to signal the upper layers */
                        TRACE_DEVEL("notifying stream before switching SID", FCGI_EV_RX_RECORD|FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
-                       fstrm->cs->flags |= CS_FL_RCV_MORE;
+                       fstrm->endp->flags |= CS_EP_RCV_MORE;
                        fcgi_strm_notify_recv(fstrm);
                }
                fstrm = tmp_fstrm;
@@ -2707,10 +2707,10 @@ static void fcgi_process_demux(struct fcgi_conn *fconn)
             fcgi_conn_read0_pending(fconn) ||
             fstrm->state == FCGI_SS_CLOSED ||
             (fstrm->flags & FCGI_SF_ES_RCVD) ||
-            (fstrm->cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING|CS_FL_EOS)))) {
+            (fstrm->endp->flags & (CS_EP_ERROR|CS_EP_ERR_PENDING|CS_EP_EOS)))) {
                /* we may have to signal the upper layers */
                TRACE_DEVEL("notifying stream before switching SID", FCGI_EV_RX_RECORD|FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
-               fstrm->cs->flags |= CS_FL_RCV_MORE;
+               fstrm->endp->flags |= CS_EP_RCV_MORE;
                fcgi_strm_notify_recv(fstrm);
        }
 
@@ -3961,18 +3961,18 @@ static size_t fcgi_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t co
                TRACE_STATE("fstrm rxbuf not allocated", FCGI_EV_STRM_RECV|FCGI_EV_FSTRM_BLK, fconn->conn, fstrm);
 
        if (b_data(&fstrm->rxbuf))
-               cs->flags |= (CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
+               cs->endp->flags |= (CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
        else {
-               cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
+               cs->endp->flags &= ~(CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
                if (fstrm->state == FCGI_SS_ERROR || (fstrm->h1m.state == H1_MSG_DONE)) {
-                       cs->flags |= CS_FL_EOI;
+                       cs->endp->flags |= CS_EP_EOI;
                        if (!(fstrm->h1m.flags & (H1_MF_VER_11|H1_MF_XFER_LEN)))
-                               cs->flags |= CS_FL_EOS;
+                               cs->endp->flags |= CS_EP_EOS;
                }
                if (fcgi_conn_read0_pending(fconn))
-                       cs->flags |= CS_FL_EOS;
-               if (cs->flags & CS_FL_ERR_PENDING)
-                       cs->flags |= CS_FL_ERROR;
+                       cs->endp->flags |= CS_EP_EOS;
+               if (cs->endp->flags & CS_EP_ERR_PENDING)
+                       cs->endp->flags |= CS_EP_ERROR;
                fcgi_release_buf(fconn, &fstrm->rxbuf);
        }
 
@@ -4025,7 +4025,7 @@ static size_t fcgi_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t co
 
                if (id < 0) {
                        fcgi_strm_close(fstrm);
-                       cs->flags |= CS_FL_ERROR;
+                       cs->endp->flags |= CS_EP_ERROR;
                        TRACE_DEVEL("couldn't get a stream ID, leaving in error", FCGI_EV_STRM_SEND|FCGI_EV_FSTRM_ERR|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
                        return 0;
                }

diff --git a/src/mux_h1.c b/src/mux_h1.c
index c504c0142d9884d7d9d4c3bc025f01e069927042..803cd8841a02ec0d481164096a45f3c9044ee7c6 100644 (file)
--- a/src/mux_h1.c
+++ b/src/mux_h1.c
@@ -1900,7 +1900,7 @@ static size_t h1_process_demux(struct h1c *h1c, struct buffer *buf, size_t count
         */
        if (((h1m->state == H1_MSG_DONE) && (h1m->flags & H1_MF_RESP)) ||
            ((h1m->state == H1_MSG_DONE) && (h1s->meth != HTTP_METH_CONNECT) && !(h1m->flags & H1_MF_CONN_UPG)))
-               h1s->cs->flags |= CS_FL_EOI;
+               h1s->endp->flags |= CS_EP_EOI;
 
   out:
        /* When Input data are pending for this message, notify upper layer that
@@ -1910,20 +1910,20 @@ static size_t h1_process_demux(struct h1c *h1c, struct buffer *buf, size_t count
         *   - Headers or trailers are pending to be copied.
         */
        if (h1s->flags & (H1S_F_RX_CONGESTED)) {
-               h1s->cs->flags |= CS_FL_RCV_MORE | CS_FL_WANT_ROOM;
+               h1s->endp->flags |= CS_EP_RCV_MORE | CS_EP_WANT_ROOM;
                TRACE_STATE("waiting for more room", H1_EV_RX_DATA|H1_EV_H1S_BLK, h1c->conn, h1s);
        }
        else {
-               h1s->cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
+               h1s->endp->flags &= ~(CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
                if (h1s->flags & H1S_F_REOS) {
-                       h1s->cs->flags |= CS_FL_EOS;
+                       h1s->endp->flags |= CS_EP_EOS;
                        if (h1m->state >= H1_MSG_DONE || !(h1m->flags & H1_MF_XFER_LEN)) {
                                /* DONE or TUNNEL or SHUTR without XFER_LEN, set
                                 * EOI on the conn-stream */
-                               h1s->cs->flags |= CS_FL_EOI;
+                               h1s->endp->flags |= CS_EP_EOI;
                        }
                        else if (h1m->state > H1_MSG_LAST_LF && h1m->state < H1_MSG_DONE) {
-                               h1s->cs->flags |= CS_FL_ERROR;
+                               h1s->endp->flags |= CS_EP_ERROR;
                                TRACE_ERROR("message aborted, set error on CS", H1_EV_RX_DATA|H1_EV_H1S_ERR, h1c->conn, h1s);
                        }
 
@@ -1942,7 +1942,7 @@ static size_t h1_process_demux(struct h1c *h1c, struct buffer *buf, size_t count
   err:
        htx_to_buf(htx, buf);
        if (h1s->cs)
-               h1s->cs->flags |= CS_FL_EOI;
+               h1s->endp->flags |= CS_EP_EOI;
        TRACE_DEVEL("leaving on error", H1_EV_RX_DATA|H1_EV_STRM_ERR, h1c->conn, h1s);
        return 0;
 }
@@ -2556,7 +2556,7 @@ static size_t h1_process_mux(struct h1c *h1c, struct buffer *buf, size_t count)
                        h1c->flags |= H1C_F_ST_ERROR;
                        TRACE_ERROR("txn done but data waiting to be sent, set error on h1c", H1_EV_H1C_ERR, h1c->conn, h1s);
                }
-               h1s->cs->flags |= CS_FL_EOI;
+               h1s->endp->flags |= CS_EP_EOI;
        }
 
        TRACE_LEAVE(H1_EV_TX_DATA, h1c->conn, h1s, chn_htx, (size_t[]){total});
@@ -3037,7 +3037,7 @@ static int h1_process(struct h1c * h1c)
                                TRACE_STATE("read0 on connection", H1_EV_H1C_RECV, conn, h1s);
                        }
                        if ((h1c->flags & H1C_F_ST_ERROR) || ((conn->flags & CO_FL_ERROR) && !b_data(&h1c->ibuf)))
-                               h1s->cs->flags |= CS_FL_ERROR;
+                               h1s->endp->flags |= CS_EP_ERROR;
                        TRACE_POINT(H1_EV_STRM_WAKE, h1c->conn, h1s);
                        h1_alert(h1s);
                }
@@ -3091,9 +3091,9 @@ static int h1_process(struct h1c * h1c)
                BUG_ON(!h1s || h1c->flags & H1C_F_ST_READY);
 
                if (conn_xprt_read0_pending(conn) || (h1s->flags & H1S_F_REOS))
-                       h1s->cs->flags |= CS_FL_EOS;
+                       h1s->endp->flags |= CS_EP_EOS;
                if ((h1c->flags & H1C_F_ST_ERROR) || (conn->flags & CO_FL_ERROR))
-                       h1s->cs->flags |= CS_FL_ERROR;
+                       h1s->endp->flags |= CS_EP_ERROR;
                h1_alert(h1s);
                TRACE_DEVEL("waiting to release the CS before releasing the connection", H1_EV_H1C_WAKE);
        }
@@ -3245,7 +3245,7 @@ struct task *h1_timeout_task(struct task *t, void *context, unsigned int state)
                if (h1c->flags & H1C_F_ST_ATTACHED) {
                        /* Don't release the H1 connection right now, we must destroy the
                         * attached CS first. Here, the H1C must not be READY */
-                       h1c->h1s->cs->flags |= (CS_FL_EOS|CS_FL_ERROR);
+                       h1c->h1s->endp->flags |= (CS_EP_EOS|CS_EP_ERROR);
                        h1_alert(h1c->h1s);
                        h1_refresh_timeout(h1c);
                        HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conns[tid].idle_conns_lock);
@@ -3685,7 +3685,7 @@ static size_t h1_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
        }
 
        if (h1c->flags & H1C_F_ST_ERROR) {
-               cs->flags |= CS_FL_ERROR;
+               cs->endp->flags |= CS_EP_ERROR;
                TRACE_ERROR("H1C on error, leaving in error", H1_EV_STRM_SEND|H1_EV_H1C_ERR|H1_EV_H1S_ERR|H1_EV_STRM_ERR, h1c->conn, h1s);
                return 0;
        }
@@ -3717,7 +3717,7 @@ static size_t h1_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
        }
 
        if (h1c->flags & H1C_F_ST_ERROR) {
-               cs->flags |= CS_FL_ERROR;
+               cs->endp->flags |= CS_EP_ERROR;
                TRACE_ERROR("reporting error to the app-layer stream", H1_EV_STRM_SEND|H1_EV_H1S_ERR|H1_EV_STRM_ERR, h1c->conn, h1s);
        }
 
@@ -3762,7 +3762,7 @@ static int h1_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int c
                        if (ret > h1m->curr_len) {
                                h1s->flags |= H1S_F_PARSING_ERROR;
                                h1c->flags |= H1C_F_ST_ERROR;
-                               cs->flags  |= CS_FL_ERROR;
+                               cs->endp->flags  |= CS_EP_ERROR;
                                TRACE_ERROR("too much payload, more than announced",
                                            H1_EV_RX_DATA|H1_EV_STRM_ERR|H1_EV_H1C_ERR|H1_EV_H1S_ERR, h1c->conn, h1s);
                                goto end;
@@ -3820,7 +3820,7 @@ static int h1_snd_pipe(struct conn_stream *cs, struct pipe *pipe)
                if (ret > h1m->curr_len) {
                        h1s->flags |= H1S_F_PROCESSING_ERROR;
                        h1c->flags |= H1C_F_ST_ERROR;
-                       cs->flags  |= CS_FL_ERROR;
+                       cs->endp->flags  |= CS_EP_ERROR;
                        TRACE_ERROR("too much payload, more than announced",
                                    H1_EV_TX_DATA|H1_EV_STRM_ERR|H1_EV_H1C_ERR|H1_EV_H1S_ERR, h1c->conn, h1s);
                        goto end;

diff --git a/src/mux_h2.c b/src/mux_h2.c
index d4f5320ecca630280d9ad5e72b1d7b5800d9f168..37f86bc7739a1f57fea975fde904b3bdd523794d 100644 (file)
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -1482,7 +1482,7 @@ static inline void h2s_close(struct h2s *h2s)
                if (!h2s->id)
                        h2s->h2c->nb_reserved--;
                if (h2s->cs) {
-                       if (!(h2s->cs->flags & CS_FL_EOS) && !b_data(&h2s->rxbuf))
+                       if (!(h2s->endp->flags & CS_EP_EOS) && !b_data(&h2s->rxbuf))
                                h2s_notify_recv(h2s);
                }
                HA_ATOMIC_DEC(&h2s->h2c->px_counters->open_streams);
@@ -2170,8 +2170,8 @@ static int h2_send_empty_data_es(struct h2s *h2s)
        return ret;
 }
 
-/* wake a specific stream and assign its conn_stream some CS_FL_* flags among
- * CS_FL_ERR_PENDING and CS_FL_ERROR if needed. The stream's state
+/* wake a specific stream and assign its conn_stream some CS_EP_* flags among
+ * CS_EP_ERR_PENDING and CS_EP_ERROR if needed. The stream's state
  * is automatically updated accordingly. If the stream is orphaned, it is
  * destroyed.
  */
@@ -2197,9 +2197,9 @@ static void h2s_wake_one_stream(struct h2s *h2s)
 
        if ((h2s->h2c->st0 >= H2_CS_ERROR || h2s->h2c->conn->flags & CO_FL_ERROR) ||
            (h2s->h2c->last_sid > 0 && (!h2s->id || h2s->id > h2s->h2c->last_sid))) {
-               h2s->cs->flags |= CS_FL_ERR_PENDING;
-               if (h2s->cs->flags & CS_FL_EOS)
-                       h2s->cs->flags |= CS_FL_ERROR;
+               h2s->endp->flags |= CS_EP_ERR_PENDING;
+               if (h2s->endp->flags & CS_EP_EOS)
+                       h2s->endp->flags |= CS_EP_ERROR;
 
                if (h2s->st < H2_SS_ERROR)
                        h2s->st = H2_SS_ERROR;
@@ -2962,7 +2962,7 @@ static struct h2s *h2c_bck_handle_headers(struct h2c *h2c, struct h2s *h2s)
        if (h2c->dff & H2_F_HEADERS_END_STREAM)
                h2s->flags |= H2_SF_ES_RCVD;
 
-       if (h2s->cs && h2s->cs->flags & CS_FL_ERROR && h2s->st < H2_SS_ERROR)
+       if (h2s->cs && (h2s->endp->flags & CS_EP_ERROR) && h2s->st < H2_SS_ERROR)
                h2s->st = H2_SS_ERROR;
        else if (h2s->flags & H2_SF_ES_RCVD) {
                if (h2s->st == H2_SS_OPEN)
@@ -3463,10 +3463,10 @@ static void h2_process_demux(struct h2c *h2c)
                     h2c_read0_pending(h2c) ||
                     h2s->st == H2_SS_CLOSED ||
                     (h2s->flags & H2_SF_ES_RCVD) ||
-                    (h2s->cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING|CS_FL_EOS)))) {
+                    (h2s->endp->flags & (CS_EP_ERROR|CS_EP_ERR_PENDING|CS_EP_EOS)))) {
                        /* we may have to signal the upper layers */
                        TRACE_DEVEL("notifying stream before switching SID", H2_EV_RX_FRAME|H2_EV_STRM_WAKE, h2c->conn, h2s);
-                       h2s->cs->flags |= CS_FL_RCV_MORE;
+                       h2s->endp->flags |= CS_EP_RCV_MORE;
                        h2s_notify_recv(h2s);
                }
                h2s = tmp_h2s;
@@ -3634,10 +3634,10 @@ static void h2_process_demux(struct h2c *h2c)
             h2c_read0_pending(h2c) ||
             h2s->st == H2_SS_CLOSED ||
             (h2s->flags & H2_SF_ES_RCVD) ||
-            (h2s->cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING|CS_FL_EOS)))) {
+            (h2s->endp->flags & (CS_EP_ERROR|CS_EP_ERR_PENDING|CS_EP_EOS)))) {
                /* we may have to signal the upper layers */
                TRACE_DEVEL("notifying stream before switching SID", H2_EV_RX_FRAME|H2_EV_H2S_WAKE, h2c->conn, h2s);
-               h2s->cs->flags |= CS_FL_RCV_MORE;
+               h2s->endp->flags |= CS_EP_RCV_MORE;
                h2s_notify_recv(h2s);
        }
 
@@ -5010,7 +5010,7 @@ next_frame:
 /* Transfer the payload of a DATA frame to the HTTP/1 side. The HTTP/2 frame
  * parser state is automatically updated. Returns > 0 if it could completely
  * send the current frame, 0 if it couldn't complete, in which case
- * CS_FL_RCV_MORE must be checked to know if some data remain pending (an empty
+ * CS_EP_RCV_MORE must be checked to know if some data remain pending (an empty
  * DATA frame can return 0 as a valid result). Stream errors are reported in
  * h2s->errcode and connection errors in h2c->errcode. The caller must already
  * have checked the frame header and ensured that the frame was complete or the
@@ -6470,7 +6470,7 @@ static size_t h2_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
        if (h2s_htx->flags & HTX_FL_PARSING_ERROR) {
                buf_htx->flags |= HTX_FL_PARSING_ERROR;
                if (htx_is_empty(buf_htx))
-                       cs->flags |= CS_FL_EOI;
+                       cs->endp->flags |= CS_EP_EOI;
        }
        else if (htx_is_empty(h2s_htx))
                buf_htx->flags |= (h2s_htx->flags & HTX_FL_EOM);
@@ -6482,19 +6482,19 @@ static size_t h2_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
 
   end:
        if (b_data(&h2s->rxbuf))
-               cs->flags |= (CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
+               cs->endp->flags |= (CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
        else {
-               cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
+               cs->endp->flags &= ~(CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
                if (h2s->flags & H2_SF_ES_RCVD) {
-                       cs->flags |= CS_FL_EOI;
+                       cs->endp->flags |= CS_EP_EOI;
                        /* Add EOS flag for tunnel */
                        if (h2s->flags & H2_SF_BODY_TUNNEL)
-                               cs->flags |= CS_FL_EOS;
+                               cs->endp->flags |= CS_EP_EOS;
                }
                if (h2c_read0_pending(h2c) || h2s->st == H2_SS_CLOSED)
-                       cs->flags |= CS_FL_EOS;
-               if (cs->flags & CS_FL_ERR_PENDING)
-                       cs->flags |= CS_FL_ERROR;
+                       cs->endp->flags |= CS_EP_EOS;
+               if (cs->endp->flags & CS_EP_ERR_PENDING)
+                       cs->endp->flags |= CS_EP_ERROR;
                if (b_size(&h2s->rxbuf)) {
                        b_free(&h2s->rxbuf);
                        offer_buffers(NULL, 1);
@@ -6546,7 +6546,7 @@ static size_t h2_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
        }
 
        if (h2s->h2c->st0 >= H2_CS_ERROR) {
-               cs->flags |= CS_FL_ERROR;
+               cs->endp->flags |= CS_EP_ERROR;
                TRACE_DEVEL("connection is in error, leaving in error", H2_EV_H2S_SEND|H2_EV_H2S_BLK|H2_EV_H2S_ERR|H2_EV_STRM_ERR, h2s->h2c->conn, h2s);
                return 0;
        }
@@ -6560,7 +6560,7 @@ static size_t h2_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
                int32_t id = h2c_get_next_sid(h2s->h2c);
 
                if (id < 0) {
-                       cs->flags |= CS_FL_ERROR;
+                       cs->endp->flags |= CS_EP_ERROR;
                        TRACE_DEVEL("couldn't get a stream ID, leaving in error", H2_EV_H2S_SEND|H2_EV_H2S_BLK|H2_EV_H2S_ERR|H2_EV_STRM_ERR, h2s->h2c->conn, h2s);
                        return 0;
                }
@@ -6672,10 +6672,10 @@ static size_t h2_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
            !b_data(&h2s->h2c->dbuf) &&
            (h2s->flags & (H2_SF_BLK_SFCTL | H2_SF_BLK_MFCTL))) {
                TRACE_DEVEL("fctl with shutr, reporting error to app-layer", H2_EV_H2S_SEND|H2_EV_STRM_SEND|H2_EV_STRM_ERR, h2s->h2c->conn, h2s);
-               if (cs->flags & CS_FL_EOS)
-                       cs->flags |= CS_FL_ERROR;
+               if (cs->endp->flags & CS_EP_EOS)
+                       cs->endp->flags |= CS_EP_ERROR;
                else
-                       cs->flags |= CS_FL_ERR_PENDING;
+                       cs->endp->flags |= CS_EP_ERR_PENDING;
        }
 
        if (total > 0 && !(h2s->flags & H2_SF_BLK_SFCTL) &&

diff --git a/src/mux_pt.c b/src/mux_pt.c
index 00cf542eda033e4a0f5b6deaae68aa06ae5e639e..7f9ce26dbaf489ab0f5e8698a41b114353bc2b96 100644 (file)
--- a/src/mux_pt.c
+++ b/src/mux_pt.c
@@ -317,7 +317,7 @@ static int mux_pt_init(struct connection *conn, struct proxy *prx, struct sessio
        }
        conn->ctx = ctx;
        ctx->cs = cs;
-       cs->flags |= CS_FL_RCV_MORE;
+       cs->endp->flags |= CS_EP_RCV_MORE;
        if (global.tune.options & GTUNE_USE_SPLICE)
                cs->endp->flags |= CS_EP_MAY_SPLICE;
 
@@ -385,7 +385,7 @@ static int mux_pt_attach(struct connection *conn, struct conn_stream *cs, struct
                conn->xprt->unsubscribe(ctx->conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
        cs_attach_mux(cs, ctx, conn);
        ctx->cs = cs;
-       cs->flags |= CS_FL_RCV_MORE;
+       cs->endp->flags |= CS_EP_RCV_MORE;
 
        TRACE_LEAVE(PT_EV_STRM_NEW, conn, cs);
        return 0;
@@ -464,7 +464,7 @@ static void mux_pt_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
 
        if (cs->endp->flags & CS_EP_SHR)
                return;
-       cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
+       cs->endp->flags &= ~(CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
        if (conn_xprt_ready(conn) && conn->xprt->shutr)
                conn->xprt->shutr(conn, conn->xprt_ctx,
                    (mode == CS_SHR_DRAIN));
@@ -516,19 +516,19 @@ static size_t mux_pt_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t
        TRACE_ENTER(PT_EV_RX_DATA, conn, cs, buf, (size_t[]){count});
 
        if (!count) {
-               cs->flags |= (CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
+               cs->endp->flags |= (CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
                goto end;
        }
        b_realign_if_empty(buf);
        ret = conn->xprt->rcv_buf(conn, conn->xprt_ctx, buf, count, flags);
        if (conn_xprt_read0_pending(conn)) {
-               cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
-               cs->flags |= CS_FL_EOS;
+               cs->endp->flags &= ~(CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+               cs->endp->flags |= CS_EP_EOS;
                TRACE_DEVEL("read0 on connection", PT_EV_RX_DATA, conn, cs);
        }
        if (conn->flags & CO_FL_ERROR) {
-               cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
-               cs->flags |= CS_FL_ERROR;
+               cs->endp->flags &= ~(CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+               cs->endp->flags |= CS_EP_ERROR;
                TRACE_DEVEL("error on connection", PT_EV_RX_DATA|PT_EV_CONN_ERR, conn, cs);
        }
   end:
@@ -550,7 +550,7 @@ static size_t mux_pt_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t
                b_del(buf, ret);
 
        if (conn->flags & CO_FL_ERROR) {
-               cs->flags |= CS_FL_ERROR;
+               cs->endp->flags |= CS_EP_ERROR;
                TRACE_DEVEL("error on connection", PT_EV_TX_DATA|PT_EV_CONN_ERR, conn, cs);
        }
 
@@ -594,11 +594,11 @@ static int mux_pt_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned i
 
        ret = conn->xprt->rcv_pipe(conn, conn->xprt_ctx, pipe, count);
        if (conn_xprt_read0_pending(conn))  {
-               cs->flags |= CS_FL_EOS;
+               cs->endp->flags |= CS_EP_EOS;
                TRACE_DEVEL("read0 on connection", PT_EV_RX_DATA, conn, cs);
        }
        if (conn->flags & CO_FL_ERROR) {
-               cs->flags |= CS_FL_ERROR;
+               cs->endp->flags |= CS_EP_ERROR;
                TRACE_DEVEL("error on connection", PT_EV_RX_DATA|PT_EV_CONN_ERR, conn, cs);
        }
 
@@ -616,7 +616,7 @@ static int mux_pt_snd_pipe(struct conn_stream *cs, struct pipe *pipe)
        ret = conn->xprt->snd_pipe(conn, conn->xprt_ctx, pipe);
 
        if (conn->flags & CO_FL_ERROR) {
-               cs->flags |= CS_FL_ERROR;
+               cs->endp->flags |= CS_EP_ERROR;
                TRACE_DEVEL("error on connection", PT_EV_TX_DATA|PT_EV_CONN_ERR, conn, cs);
        }
 

diff --git a/src/mux_quic.c b/src/mux_quic.c
index c64f8d0f8e0b3bbee362bdbe4a594d2978902408..e207b3aef1d30edada90fa048f1e9756873295a9 100644 (file)
--- a/src/mux_quic.c
+++ b/src/mux_quic.c
@@ -1144,15 +1144,15 @@ static size_t qc_rcv_buf(struct conn_stream *cs, struct buffer *buf,
 
  end:
        if (b_data(&qcs->rx.app_buf)) {
-               cs->flags |= (CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
+               cs->endp->flags |= (CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
        }
        else {
-               cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
-               if (cs->flags & CS_FL_ERR_PENDING)
-                       cs->flags |= CS_FL_ERROR;
+               cs->endp->flags &= ~(CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+               if (cs->endp->flags & CS_EP_ERR_PENDING)
+                       cs->endp->flags |= CS_EP_ERROR;
 
                if (fin)
-                       cs->flags |= (CS_FL_EOI|CS_FL_EOS);
+                       cs->endp->flags |= (CS_EP_EOI|CS_EP_EOS);
 
                if (b_size(&qcs->rx.app_buf)) {
                        b_free(&qcs->rx.app_buf);
@@ -1213,7 +1213,7 @@ static int qc_unsubscribe(struct conn_stream *cs, int event_type, struct wait_ev
 }
 
 /* Loop through all qcs from <qcc>. If CO_FL_ERROR is set on the connection,
- * report CS_FL_ERR_PENDING|CS_FL_ERROR on the attached conn-streams and wake
+ * report CS_EP_ERR_PENDING|CS_EP_ERROR on the attached conn-streams and wake
  * them.
  */
 static int qc_wake_some_streams(struct qcc *qcc)
@@ -1231,9 +1231,9 @@ static int qc_wake_some_streams(struct qcc *qcc)
                        continue;
 
                if (qcc->conn->flags & CO_FL_ERROR) {
-                       qcs->cs->flags |= CS_FL_ERR_PENDING;
-                       if (qcs->cs->flags & CS_FL_EOS)
-                               qcs->cs->flags |= CS_FL_ERROR;
+                       qcs->endp->flags |= CS_EP_ERR_PENDING;
+                       if (qcs->endp->flags & CS_EP_EOS)
+                               qcs->endp->flags |= CS_EP_ERROR;
 
                        if (qcs->subs) {
                                qcs_notify_recv(qcs);

diff --git a/src/stats.c b/src/stats.c
index 2d1a33ce7f79fda622f0c0e6eaaeee9a173ea5bc..e18a5164e0dee805653120cc2c6f0be6338c5e89 100644 (file)
--- a/src/stats.c
+++ b/src/stats.c
@@ -4330,7 +4330,7 @@ static void http_stats_io_handler(struct appctx *appctx)
                        channel_add_input(res, 1);
                }
                res_htx->flags |= HTX_FL_EOM;
-               si->cs->flags |= CS_FL_EOI;
+               si->cs->endp->flags |= CS_EP_EOI;
                res->flags |= CF_EOI;
                appctx->st0 = STAT_HTTP_END;
        }

diff --git a/src/stream_interface.c b/src/stream_interface.c
index 134dfcc3d5e13299a325fa043604b64e25962d8e..194c5ff11ae44efe61c7641020c62bb062a10625 100644 (file)
--- a/src/stream_interface.c
+++ b/src/stream_interface.c
@@ -636,7 +636,7 @@ static int si_cs_process(struct conn_stream *cs)
         */
 
        if (si->state >= SI_ST_CON) {
-               if ((cs->flags & CS_FL_ERROR) || si_is_conn_error(si))
+               if ((cs->endp->flags & CS_EP_ERROR) || si_is_conn_error(si))
                        si->flags |= SI_FL_ERR;
        }
 
@@ -666,7 +666,7 @@ static int si_cs_process(struct conn_stream *cs)
         *       wake callback. Otherwise si_cs_recv()/si_cs_send() already take
         *       care of it.
         */
-       if (cs->flags & CS_FL_EOS && !(ic->flags & CF_SHUTR)) {
+       if (cs->endp->flags & CS_EP_EOS && !(ic->flags & CF_SHUTR)) {
                /* we received a shutdown */
                ic->flags |= CF_READ_NULL;
                if (ic->flags & CF_AUTO_CLOSE)
@@ -681,7 +681,7 @@ static int si_cs_process(struct conn_stream *cs)
         *       wake callback. Otherwise si_cs_recv()/si_cs_send() already take
         *       care of it.
         */
-       if ((cs->flags & CS_FL_EOI) && !(ic->flags & CF_EOI))
+       if ((cs->endp->flags & CS_EP_EOI) && !(ic->flags & CF_EOI))
                ic->flags |= (CF_EOI|CF_READ_PARTIAL);
 
        /* Second step : update the stream-int and channels, try to forward any
@@ -707,7 +707,7 @@ static int si_cs_send(struct conn_stream *cs)
        int ret;
        int did_send = 0;
 
-       if (cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING) || si_is_conn_error(si)) {
+       if (cs->endp->flags & (CS_EP_ERROR|CS_EP_ERR_PENDING) || si_is_conn_error(si)) {
                /* We're probably there because the tasklet was woken up,
                 * but process_stream() ran before, detected there were an
                 * error and put the si back to SI_ST_TAR. There's still
@@ -830,7 +830,7 @@ static int si_cs_send(struct conn_stream *cs)
                si_rx_room_rdy(si_opposite(si));
        }
 
-       if (cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING)) {
+       if (cs->endp->flags & (CS_EP_ERROR|CS_EP_ERR_PENDING)) {
                si->flags |= SI_FL_ERR;
                return 1;
        }
@@ -1213,7 +1213,7 @@ static void stream_int_chk_snd_conn(struct stream_interface *si)
        if (!(si->wait_event.events & SUB_RETRY_SEND) && !channel_is_empty(si_oc(si)))
                si_cs_send(cs);
 
-       if (cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING) || si_is_conn_error(si)) {
+       if (cs->endp->flags & (CS_EP_ERROR|CS_EP_ERR_PENDING) || si_is_conn_error(si)) {
                /* Write error on the file descriptor */
                if (si->state >= SI_ST_CON)
                        si->flags |= SI_FL_ERR;
@@ -1316,7 +1316,7 @@ static int si_cs_recv(struct conn_stream *cs)
                return 0;
 
        /* stop here if we reached the end of data */
-       if (cs->flags & CS_FL_EOS)
+       if (cs->endp->flags & CS_EP_EOS)
                goto end_recv;
 
        /* stop immediately on errors. Note that we DON'T want to stop on
@@ -1325,15 +1325,15 @@ static int si_cs_recv(struct conn_stream *cs)
         * happens when we send too large a request to a backend server
         * which rejects it before reading it all.
         */
-       if (!(cs->flags & CS_FL_RCV_MORE)) {
+       if (!(cs->endp->flags & CS_EP_RCV_MORE)) {
                if (!conn_xprt_ready(conn))
                        return 0;
-               if (cs->flags & CS_FL_ERROR)
+               if (cs->endp->flags & CS_EP_ERROR)
                        goto end_recv;
        }
 
        /* prepare to detect if the mux needs more room */
-       cs->flags &= ~CS_FL_WANT_ROOM;
+       cs->endp->flags &= ~CS_EP_WANT_ROOM;
 
        if ((ic->flags & (CF_STREAMER | CF_STREAMER_FAST)) && !co_data(ic) &&
            global.tune.idle_timer &&
@@ -1385,7 +1385,7 @@ static int si_cs_recv(struct conn_stream *cs)
                        ic->flags |= CF_READ_PARTIAL;
                }
 
-               if (cs->flags & (CS_FL_EOS|CS_FL_ERROR))
+               if (cs->endp->flags & (CS_EP_EOS|CS_EP_ERROR))
                        goto end_recv;
 
                if (conn->flags & CO_FL_WAIT_ROOM) {
@@ -1440,9 +1440,9 @@ static int si_cs_recv(struct conn_stream *cs)
         * that if such an event is not handled above in splice, it will be handled here by
         * recv().
         */
-       while ((cs->flags & CS_FL_RCV_MORE) ||
+       while ((cs->endp->flags & CS_EP_RCV_MORE) ||
               (!(conn->flags & CO_FL_HANDSHAKE) &&
-              (!(cs->flags & (CS_FL_ERROR|CS_FL_EOS))) && !(ic->flags & CF_SHUTR))) {
+              (!(cs->endp->flags & (CS_EP_ERROR|CS_EP_EOS))) && !(ic->flags & CF_SHUTR))) {
                int cur_flags = flags;
 
                /* Compute transient CO_RFL_* flags */
@@ -1451,13 +1451,13 @@ static int si_cs_recv(struct conn_stream *cs)
                }
 
                /* <max> may be null. This is the mux responsibility to set
-                * CS_FL_RCV_MORE on the CS if more space is needed.
+                * CS_EP_RCV_MORE on the CS if more space is needed.
                 */
                max = channel_recv_max(ic);
                ret = conn->mux->rcv_buf(cs, &ic->buf, max, cur_flags);
 
-               if (cs->flags & CS_FL_WANT_ROOM) {
-                       /* CS_FL_WANT_ROOM must not be reported if the channel's
+               if (cs->endp->flags & CS_EP_WANT_ROOM) {
+                       /* CS_EP_WANT_ROOM must not be reported if the channel's
                         * buffer is empty.
                         */
                        BUG_ON(c_empty(ic));
@@ -1501,7 +1501,7 @@ static int si_cs_recv(struct conn_stream *cs)
                 * the channel's policies.This way, we are still able to receive
                 * shutdowns.
                 */
-               if (cs->flags & CS_FL_EOI)
+               if (cs->endp->flags & CS_EP_EOI)
                        break;
 
                if ((ic->flags & CF_READ_DONTWAIT) || --read_poll <= 0) {
@@ -1587,16 +1587,16 @@ static int si_cs_recv(struct conn_stream *cs)
 
        /* Report EOI on the channel if it was reached from the mux point of
         * view. */
-       if ((cs->flags & CS_FL_EOI) && !(ic->flags & CF_EOI)) {
+       if ((cs->endp->flags & CS_EP_EOI) && !(ic->flags & CF_EOI)) {
                ic->flags |= (CF_EOI|CF_READ_PARTIAL);
                ret = 1;
        }
 
-       if (cs->flags & CS_FL_ERROR) {
+       if (cs->endp->flags & CS_EP_ERROR) {
                si->flags |= SI_FL_ERR;
                ret = 1;
        }
-       else if (cs->flags & CS_FL_EOS) {
+       else if (cs->endp->flags & CS_EP_EOS) {
                /* we received a shutdown */
                ic->flags |= CF_READ_NULL;
                if (ic->flags & CF_AUTO_CLOSE)

diff --git a/src/tcpcheck.c b/src/tcpcheck.c
index 53ee771f4695fca52b3b35235b5d32de4bbb4deb..930735b70d851f91a6b52841426dd3dea4865511 100644 (file)
--- a/src/tcpcheck.c
+++ b/src/tcpcheck.c
@@ -1483,7 +1483,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_send(struct check *check, struct tcpcheck_r
        TRACE_DATA("send data", CHK_EV_TCPCHK_SND|CHK_EV_TX_DATA, check);
        if (conn->mux->snd_buf(cs, &check->bo,
                               (IS_HTX_CONN(conn) ? (htxbuf(&check->bo))->data: b_data(&check->bo)), 0) <= 0) {
-               if ((conn->flags & CO_FL_ERROR) || (cs->flags & CS_FL_ERROR)) {
+               if ((conn->flags & CO_FL_ERROR) || (cs->endp->flags & CS_EP_ERROR)) {
                        ret = TCPCHK_EVAL_STOP;
                        TRACE_DEVEL("connection error during send", CHK_EV_TCPCHK_SND|CHK_EV_TX_DATA|CHK_EV_TX_ERR, check);
                        goto out;
@@ -1547,7 +1547,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_recv(struct check *check, struct tcpcheck_r
                goto wait_more_data;
        }
 
-       if (cs->flags & CS_FL_EOS)
+       if (cs->endp->flags & CS_EP_EOS)
                goto end_recv;
 
        if (check->state & CHK_ST_IN_ALLOC) {
@@ -1564,15 +1564,15 @@ enum tcpcheck_eval_ret tcpcheck_eval_recv(struct check *check, struct tcpcheck_r
        /* errors on the connection and the conn-stream were already checked */
 
        /* prepare to detect if the mux needs more room */
-       cs->flags &= ~CS_FL_WANT_ROOM;
+       cs->endp->flags &= ~CS_EP_WANT_ROOM;
 
-       while ((cs->flags & CS_FL_RCV_MORE) ||
-              (!(conn->flags & CO_FL_ERROR) && !(cs->flags & (CS_FL_ERROR|CS_FL_EOS)))) {
+       while ((cs->endp->flags & CS_EP_RCV_MORE) ||
+              (!(conn->flags & CO_FL_ERROR) && !(cs->endp->flags & (CS_EP_ERROR|CS_EP_EOS)))) {
                max = (IS_HTX_CS(cs) ?  htx_free_space(htxbuf(&check->bi)) : b_room(&check->bi));
                read = conn->mux->rcv_buf(cs, &check->bi, max, 0);
                cur_read += read;
                if (!read ||
-                   (cs->flags & CS_FL_WANT_ROOM) ||
+                   (cs->endp->flags & CS_EP_WANT_ROOM) ||
                    (--read_poll <= 0) ||
                    (read < max && read >= global.tune.recv_enough))
                        break;
@@ -1580,7 +1580,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_recv(struct check *check, struct tcpcheck_r
 
   end_recv:
        is_empty = (IS_HTX_CS(cs) ? htx_is_empty(htxbuf(&check->bi)) : !b_data(&check->bi));
-       if (is_empty && ((conn->flags & CO_FL_ERROR) || (cs->flags & CS_FL_ERROR))) {
+       if (is_empty && ((conn->flags & CO_FL_ERROR) || (cs->endp->flags & CS_EP_ERROR))) {
                /* Report network errors only if we got no other data. Otherwise
                 * we'll let the upper layers decide whether the response is OK
                 * or not. It is very common that an RST sent by the server is
@@ -1590,11 +1590,11 @@ enum tcpcheck_eval_ret tcpcheck_eval_recv(struct check *check, struct tcpcheck_r
                goto stop;
        }
        if (!cur_read) {
-               if (cs->flags & CS_FL_EOI) {
+               if (cs->endp->flags & CS_EP_EOI) {
                        /* If EOI is set, it means there is a response or an error */
                        goto out;
                }
-               if (!(cs->flags & (CS_FL_WANT_ROOM|CS_FL_ERROR|CS_FL_EOS))) {
+               if (!(cs->endp->flags & (CS_EP_WANT_ROOM|CS_EP_ERROR|CS_EP_EOS))) {
                        conn->mux->subscribe(cs, SUB_RETRY_RECV, &check->wait_list);
                        TRACE_DEVEL("waiting for response", CHK_EV_RX_DATA, check);
                        goto wait_more_data;
@@ -2140,7 +2140,7 @@ int tcpcheck_main(struct check *check)
         */
 
        /* 1- check for connection error, if any */
-       if ((conn && conn->flags & CO_FL_ERROR) || (cs->flags & CS_FL_ERROR))
+       if ((conn && conn->flags & CO_FL_ERROR) || (cs->endp->flags & CS_EP_ERROR))
                goto out_end_tcpcheck;
 
        /* 2- check if a rule must be resume. It happens if check->current_step
@@ -2222,7 +2222,7 @@ int tcpcheck_main(struct check *check)
                                        goto out_end_tcpcheck;
                                else if (eval_ret == TCPCHK_EVAL_WAIT)
                                        goto out;
-                               last_read = ((conn->flags & CO_FL_ERROR) || (cs->flags & (CS_FL_ERROR|CS_FL_EOS)));
+                               last_read = ((conn->flags & CO_FL_ERROR) || (cs->endp->flags & (CS_EP_ERROR|CS_EP_EOS)));
                                must_read = 0;
                        }
 
@@ -2303,7 +2303,7 @@ int tcpcheck_main(struct check *check)
        TRACE_PROTO("tcp-check passed", CHK_EV_TCPCHK_EVAL, check);
 
   out_end_tcpcheck:
-       if ((conn && conn->flags & CO_FL_ERROR) || (cs->flags & CS_FL_ERROR)) {
+       if ((conn && conn->flags & CO_FL_ERROR) || (cs->endp->flags & CS_EP_ERROR)) {
                TRACE_ERROR("report connection error", CHK_EV_TCPCHK_EVAL|CHK_EV_TCPCHK_ERR, check);
                chk_report_conn_err(check, errno, 0);
        }