mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-08-06 15:17:01 +02:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
Christopher Faulet 2022-03-24 10:27:02 +01:00
parent 9ec2f4dc7c
commit b041b23ae4
19 changed files with 188 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
addons/promex/service-prometheus.c
View File

@ -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 */

12
dev/flags/flags.c
View File

@ -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);

24
include/haproxy/conn_stream-t.h
View File

@ -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 */

8
include/haproxy/conn_stream.h
View File

@ -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

4
src/backend.c
View File

@ -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 */

2
src/cache.c
View File

@ -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;
}

41
src/check.c
View File

@ -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 */

34
src/conn_stream.c
View File

@ -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;
}

2
src/hlua.c
View File

@ -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;

1
src/http_ana.c
View File

@ -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;

2
src/http_client.c
View File

@ -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;
}

36
src/mux_fcgi.c
View File

@ -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;
}

32
src/mux_h1.c
View File

@ -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;

50
src/mux_h2.c
View File

@ -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) &&

24
src/mux_pt.c
View File

@ -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);
}

18
src/mux_quic.c
View File

@ -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);

2
src/stats.c
View File

@ -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;
}

40
src/stream_interface.c
View File

@ -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)

24
src/tcpcheck.c
View File

@ -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);
}