From b041b23ae430889ae9ab40da6c1abecd2cc21c7b Mon Sep 17 00:00:00 2001 From: Christopher Faulet Date: Thu, 24 Mar 2022 10:27:02 +0100 Subject: [PATCH] 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. --- addons/promex/service-prometheus.c | 2 +- dev/flags/flags.c | 12 +++---- include/haproxy/conn_stream-t.h | 24 +++++++------- include/haproxy/conn_stream.h | 8 ++--- src/backend.c | 4 +-- src/cache.c | 2 +- src/check.c | 41 ++++++++++++------------ src/conn_stream.c | 34 +++++++++++++++----- src/hlua.c | 2 +- src/http_ana.c | 1 - src/http_client.c | 2 +- src/mux_fcgi.c | 36 ++++++++++----------- src/mux_h1.c | 32 +++++++++---------- src/mux_h2.c | 50 +++++++++++++++--------------- src/mux_pt.c | 24 +++++++------- src/mux_quic.c | 18 +++++------ src/stats.c | 2 +- src/stream_interface.c | 40 ++++++++++++------------ src/tcpcheck.c | 24 +++++++------- 19 files changed, 188 insertions(+), 170 deletions(-) diff --git a/addons/promex/service-prometheus.c b/addons/promex/service-prometheus.c index 61bf4653f..e02da75b8 100644 --- 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 08cb2e89f..ddfd87906 100644 --- 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 842ce8443..bde6600ca 100644 --- 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 ca5a99c93..aa708c75a 100644 --- 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 f57d05d84..09f10e8f0 100644 --- a/src/backend.c +++ b/src/backend.c @@ -1743,7 +1743,7 @@ static int connect_server(struct stream *s) * 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 @@ static int connect_server(struct stream *s) * 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 1aa1103a6..ce6c7ea6f 100644 --- 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 47a53db3d..058b23322 100644 --- 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 d45eba63c..bb5178448 100644 --- 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 af26aae03..931e74137 100644 --- 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 57bb3f1cd..05b62fe02 100644 --- 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 1e87a5033..c0677368c 100644 --- 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 a74554e55..9af915dc7 100644 --- 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 c504c0142..803cd8841 100644 --- 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 d4f5320ec..37f86bc77 100644 --- 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 @@ static int h2c_decode_headers(struct h2c *h2c, struct buffer *rxbuf, uint32_t *f /* 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 00cf542ed..7f9ce26db 100644 --- 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 c64f8d0f8..e207b3aef 100644 --- 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 . 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 2d1a33ce7..e18a5164e 100644 --- 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 134dfcc3d..194c5ff11 100644 --- 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) } /* 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 53ee771f4..930735b70 100644 --- 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); }