Let's now use the new flag names for the stream endpoint.
}
res_htx->flags |= HTX_FL_EOM;
res->flags |= CF_EOI;
- se_fl_set(appctx->endp, CS_EP_EOI);
+ se_fl_set(appctx->endp, SE_FL_EOI);
appctx->st0 = PROMEX_ST_END;
/* fall through */
return;
}
- SHOW_FLAG(f, CS_EP_RXBLK_CHAN);
- SHOW_FLAG(f, CS_EP_RXBLK_BUFF);
- SHOW_FLAG(f, CS_EP_RXBLK_ROOM);
- SHOW_FLAG(f, CS_EP_RXBLK_SHUT);
- SHOW_FLAG(f, CS_EP_RXBLK_CONN);
- SHOW_FLAG(f, CS_EP_RX_WAIT_EP);
- SHOW_FLAG(f, CS_EP_WANT_GET);
- SHOW_FLAG(f, CS_EP_WAIT_DATA);
- 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);
- SHOW_FLAG(f, CS_EP_SHWS);
- SHOW_FLAG(f, CS_EP_SHWN);
- SHOW_FLAG(f, CS_EP_SHRR);
- SHOW_FLAG(f, CS_EP_SHRD);
- SHOW_FLAG(f, CS_EP_ORPHAN);
- SHOW_FLAG(f, CS_EP_DETACHED);
- SHOW_FLAG(f, CS_EP_T_APPLET);
- SHOW_FLAG(f, CS_EP_T_MUX);
+ SHOW_FLAG(f, SE_FL_RXBLK_CHAN);
+ SHOW_FLAG(f, SE_FL_RXBLK_BUFF);
+ SHOW_FLAG(f, SE_FL_RXBLK_ROOM);
+ SHOW_FLAG(f, SE_FL_RXBLK_SHUT);
+ SHOW_FLAG(f, SE_FL_RXBLK_CONN);
+ SHOW_FLAG(f, SE_FL_RX_WAIT_EP);
+ SHOW_FLAG(f, SE_FL_WANT_GET);
+ SHOW_FLAG(f, SE_FL_WAIT_DATA);
+ SHOW_FLAG(f, SE_FL_KILL_CONN);
+ SHOW_FLAG(f, SE_FL_WAIT_FOR_HS);
+ SHOW_FLAG(f, SE_FL_WANT_ROOM);
+ SHOW_FLAG(f, SE_FL_ERROR);
+ SHOW_FLAG(f, SE_FL_ERR_PENDING);
+ SHOW_FLAG(f, SE_FL_EOS);
+ SHOW_FLAG(f, SE_FL_EOI);
+ SHOW_FLAG(f, SE_FL_RCV_MORE);
+ SHOW_FLAG(f, SE_FL_MAY_SPLICE);
+ SHOW_FLAG(f, SE_FL_WEBSOCKET);
+ SHOW_FLAG(f, SE_FL_NOT_FIRST);
+ SHOW_FLAG(f, SE_FL_SHWS);
+ SHOW_FLAG(f, SE_FL_SHWN);
+ SHOW_FLAG(f, SE_FL_SHRR);
+ SHOW_FLAG(f, SE_FL_SHRD);
+ SHOW_FLAG(f, SE_FL_ORPHAN);
+ SHOW_FLAG(f, SE_FL_DETACHED);
+ SHOW_FLAG(f, SE_FL_T_APPLET);
+ SHOW_FLAG(f, SE_FL_T_MUX);
if (f) {
printf("EXTRA(0x%08x)", f);
LIST_DEL_INIT(&appctx->buffer_wait.list);
if (appctx->sess)
session_free(appctx->sess);
- BUG_ON(appctx->endp && !se_fl_test(appctx->endp, CS_EP_ORPHAN));
+ BUG_ON(appctx->endp && !se_fl_test(appctx->endp, SE_FL_ORPHAN));
cs_endpoint_free(appctx->endp);
pool_free(pool_head_appctx, appctx);
_HA_ATOMIC_DEC(&nb_applets);
#include <haproxy/obj_type-t.h>
#include <haproxy/connection-t.h>
-/* CS endpoint flags */
- enum {
- CS_EP_NONE = 0x00000000, /* For initialization purposes */
+/* Stream Endpoint Flags */
+enum se_flags {
+ SE_FL_NONE = 0x00000000, /* For initialization purposes */
/* Endpoint types */
- CS_EP_T_MUX = 0x00000001, /* The endpoint is a mux (the target may be NULL before the mux init) */
- CS_EP_T_APPLET = 0x00000002, /* The endpoint is an applet */
+ SE_FL_T_MUX = 0x00000001, /* The endpoint is a mux (the target may be NULL before the mux init) */
+ SE_FL_T_APPLET = 0x00000002, /* The endpoint is an applet */
/* unused: 0x00000004 .. 0x00000008 */
/* Endpoint states: none == attached to a mux with a conn-stream */
- CS_EP_DETACHED = 0x00000010, /* The endpoint is detached (no mux/no applet) */
- CS_EP_ORPHAN = 0x00000020, /* The endpoint is orphan (no conn-stream) */
+ SE_FL_DETACHED = 0x00000010, /* The endpoint is detached (no mux/no applet) */
+ SE_FL_ORPHAN = 0x00000020, /* The endpoint is orphan (no conn-stream) */
/* unused: 0x00000040 .. 0x00000080 */
- CS_EP_SHRD = 0x00000100, /* read shut, draining extra data */
- CS_EP_SHRR = 0x00000200, /* read shut, resetting extra data */
- CS_EP_SHR = CS_EP_SHRD | CS_EP_SHRR, /* read shut status */
+ SE_FL_SHRD = 0x00000100, /* read shut, draining extra data */
+ SE_FL_SHRR = 0x00000200, /* read shut, resetting extra data */
+ SE_FL_SHR = SE_FL_SHRD | SE_FL_SHRR, /* read shut status */
- CS_EP_SHWN = 0x00000400, /* write shut, verbose mode */
- CS_EP_SHWS = 0x00000800, /* write shut, silent mode */
- CS_EP_SHW = CS_EP_SHWN | CS_EP_SHWS, /* write shut status */
+ SE_FL_SHWN = 0x00000400, /* write shut, verbose mode */
+ SE_FL_SHWS = 0x00000800, /* write shut, silent mode */
+ SE_FL_SHW = SE_FL_SHWN | SE_FL_SHWS, /* write shut status */
/* 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_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 */
+ SE_FL_NOT_FIRST = 0x00001000, /* This conn-stream is not the first one for the endpoint */
+ SE_FL_WEBSOCKET = 0x00002000, /* The endpoint uses the websocket proto */
+ SE_FL_EOI = 0x00004000, /* end-of-input reached */
+ SE_FL_EOS = 0x00008000, /* End of stream delivered to data layer */
+ SE_FL_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 */
- CS_EP_ENDP_MASK = 0x001ff000, /* Mask for flags set by the endpoint */
+ SE_FL_ERR_PENDING= 0x00020000, /* An error is pending, but there's still data to be read */
+ SE_FL_MAY_SPLICE = 0x00040000, /* The endpoint may use the kernel splicing to forward data to the other side (implies SE_FL_CAN_SPLICE) */
+ SE_FL_RCV_MORE = 0x00080000, /* Endpoint may have more bytes to transfer */
+ SE_FL_WANT_ROOM = 0x00100000, /* More bytes to transfer, but not enough room */
+ SE_FL_ENDP_MASK = 0x001ff000, /* Mask for flags set by the endpoint */
/* following flags are supposed to be set by the app layer and read by
* the endpoint :
*/
- CS_EP_WAIT_FOR_HS = 0x00200000, /* This stream is waiting for handhskae */
- CS_EP_KILL_CONN = 0x00400000, /* must kill the connection when the CS closes */
- CS_EP_WAIT_DATA = 0x00800000, /* CS waits for more outgoing data to send */
- CS_EP_WANT_GET = 0x01000000, /* CS would like to get some data from the buffer */
- CS_EP_RX_WAIT_EP = 0x02000000, /* CS waits for more data from the end point */
- CS_EP_RXBLK_CHAN = 0x04000000, /* the channel doesn't want the CS to introduce data */
- CS_EP_RXBLK_BUFF = 0x08000000, /* CS waits for a buffer allocation to complete */
- CS_EP_RXBLK_ROOM = 0x10000000, /* CS waits for more buffer room to store incoming data */
- CS_EP_RXBLK_SHUT = 0x20000000, /* input is now closed, nothing new will ever come */
- CS_EP_RXBLK_CONN = 0x40000000, /* other side is not connected */
- CS_EP_RXBLK_ANY = 0x7C000000, /* any of the RXBLK flags above */
- CS_EP_APP_MASK = 0x7fe00000, /* Mask for flags set by the app layer */
- };
+ SE_FL_WAIT_FOR_HS = 0x00200000, /* This stream is waiting for handhskae */
+ SE_FL_KILL_CONN = 0x00400000, /* must kill the connection when the CS closes */
+ SE_FL_WAIT_DATA = 0x00800000, /* CS waits for more outgoing data to send */
+ SE_FL_WANT_GET = 0x01000000, /* CS would like to get some data from the buffer */
+ SE_FL_RX_WAIT_EP = 0x02000000, /* CS waits for more data from the end point */
+ SE_FL_RXBLK_CHAN = 0x04000000, /* the channel doesn't want the CS to introduce data */
+ SE_FL_RXBLK_BUFF = 0x08000000, /* CS waits for a buffer allocation to complete */
+ SE_FL_RXBLK_ROOM = 0x10000000, /* CS waits for more buffer room to store incoming data */
+ SE_FL_RXBLK_SHUT = 0x20000000, /* input is now closed, nothing new will ever come */
+ SE_FL_RXBLK_CONN = 0x40000000, /* other side is not connected */
+ SE_FL_RXBLK_ANY = 0x7C000000, /* any of the RXBLK flags above */
+ SE_FL_APP_MASK = 0x7fe00000, /* Mask for flags set by the app layer */
+};
/* conn_stream flags */
enum {
* <target> is the mux or the appctx
* <conn> is the connection for connection-based streams
* <cs> is the conn_stream we're attached to, or NULL
- * <flags> CS_EP_*
+ * <flags> SE_FL_*
*/
struct cs_endpoint {
void *target;
}
static inline struct connection *cs_conn(const struct conn_stream *cs)
{
- if (sc_ep_test(cs, CS_EP_T_MUX))
+ if (sc_ep_test(cs, SE_FL_T_MUX))
return __cs_conn(cs);
return NULL;
}
}
static inline struct appctx *cs_mux(const struct conn_stream *cs)
{
- if (sc_ep_test(cs, CS_EP_T_MUX))
+ if (sc_ep_test(cs, SE_FL_T_MUX))
return __cs_mux(cs);
return NULL;
}
}
static inline struct appctx *cs_appctx(const struct conn_stream *cs)
{
- if (sc_ep_test(cs, CS_EP_T_APPLET))
+ if (sc_ep_test(cs, SE_FL_T_APPLET))
return __cs_appctx(cs);
return NULL;
}
BUG_ON(!cs_conn(cs));
- if (sc_ep_test(cs, CS_EP_SHR))
+ if (sc_ep_test(cs, SE_FL_SHR))
return;
/* clean data-layer shutdown */
mux = cs_conn_mux(cs);
if (mux && mux->shutr)
mux->shutr(cs, mode);
- sc_ep_set(cs, (mode == CO_SHR_DRAIN) ? CS_EP_SHRD : CS_EP_SHRR);
+ sc_ep_set(cs, (mode == CO_SHR_DRAIN) ? SE_FL_SHRD : SE_FL_SHRR);
}
/* shut write */
BUG_ON(!cs_conn(cs));
- if (sc_ep_test(cs, CS_EP_SHW))
+ if (sc_ep_test(cs, SE_FL_SHW))
return;
/* clean data-layer shutdown */
mux = cs_conn_mux(cs);
if (mux && mux->shutw)
mux->shutw(cs, mode);
- sc_ep_set(cs, (mode == CO_SHW_NORMAL) ? CS_EP_SHWN : CS_EP_SHWS);
+ sc_ep_set(cs, (mode == CO_SHW_NORMAL) ? SE_FL_SHWN : SE_FL_SHWS);
}
/* completely close a conn_stream (but do not detach it) */
cs_conn_shutr(cs, CO_SHR_DRAIN);
}
-/* sets CS_EP_ERROR or CS_EP_ERR_PENDING on the endpoint */
+/* sets SE_FL_ERROR or SE_FL_ERR_PENDING on the endpoint */
static inline void cs_ep_set_error(struct cs_endpoint *endp)
{
- if (se_fl_test(endp, CS_EP_EOS))
- se_fl_set(endp, CS_EP_ERROR);
+ if (se_fl_test(endp, SE_FL_EOS))
+ se_fl_set(endp, SE_FL_ERROR);
else
- se_fl_set(endp, CS_EP_ERR_PENDING);
+ se_fl_set(endp, SE_FL_ERR_PENDING);
}
/* Retrieves any valid conn_stream from this connection, preferably the first
/* Returns non-zero if the conn-stream's Rx path is blocked */
static inline int cs_rx_blocked(const struct conn_stream *cs)
{
- return !!sc_ep_test(cs, CS_EP_RXBLK_ANY);
+ return !!sc_ep_test(cs, SE_FL_RXBLK_ANY);
}
*/
static inline int cs_rx_blocked_room(const struct conn_stream *cs)
{
- return !!sc_ep_test(cs, CS_EP_RXBLK_ROOM);
+ return !!sc_ep_test(cs, SE_FL_RXBLK_ROOM);
}
/* Returns non-zero if the conn-stream's endpoint is ready to receive */
static inline int cs_rx_endp_ready(const struct conn_stream *cs)
{
- return !sc_ep_test(cs, CS_EP_RX_WAIT_EP);
+ return !sc_ep_test(cs, SE_FL_RX_WAIT_EP);
}
/* The conn-stream announces it is ready to try to deliver more data to the input buffer */
static inline void cs_rx_endp_more(struct conn_stream *cs)
{
- sc_ep_clr(cs, CS_EP_RX_WAIT_EP);
+ sc_ep_clr(cs, SE_FL_RX_WAIT_EP);
}
/* The conn-stream announces it doesn't have more data for the input buffer */
static inline void cs_rx_endp_done(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_RX_WAIT_EP);
+ sc_ep_set(cs, SE_FL_RX_WAIT_EP);
}
/* Tell a conn-stream the input channel is OK with it sending it some data */
static inline void cs_rx_chan_rdy(struct conn_stream *cs)
{
- sc_ep_clr(cs, CS_EP_RXBLK_CHAN);
+ sc_ep_clr(cs, SE_FL_RXBLK_CHAN);
}
/* Tell a conn-stream the input channel is not OK with it sending it some data */
static inline void cs_rx_chan_blk(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_RXBLK_CHAN);
+ sc_ep_set(cs, SE_FL_RXBLK_CHAN);
}
/* Tell a conn-stream the other side is connected */
static inline void cs_rx_conn_rdy(struct conn_stream *cs)
{
- sc_ep_clr(cs, CS_EP_RXBLK_CONN);
+ sc_ep_clr(cs, SE_FL_RXBLK_CONN);
}
/* Tell a conn-stream it must wait for the other side to connect */
static inline void cs_rx_conn_blk(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_RXBLK_CONN);
+ sc_ep_set(cs, SE_FL_RXBLK_CONN);
}
/* The conn-stream just got the input buffer it was waiting for */
static inline void cs_rx_buff_rdy(struct conn_stream *cs)
{
- sc_ep_clr(cs, CS_EP_RXBLK_BUFF);
+ sc_ep_clr(cs, SE_FL_RXBLK_BUFF);
}
/* The conn-stream failed to get an input buffer and is waiting for it.
*/
static inline void cs_rx_buff_blk(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_RXBLK_BUFF);
+ sc_ep_set(cs, SE_FL_RXBLK_BUFF);
}
/* Tell a conn-stream some room was made in the input buffer */
static inline void cs_rx_room_rdy(struct conn_stream *cs)
{
- sc_ep_clr(cs, CS_EP_RXBLK_ROOM);
+ sc_ep_clr(cs, SE_FL_RXBLK_ROOM);
}
/* The conn-stream announces it failed to put data into the input buffer
*/
static inline void cs_rx_room_blk(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_RXBLK_ROOM);
+ sc_ep_set(cs, SE_FL_RXBLK_ROOM);
}
/* The conn-stream announces it will never put new data into the input
*/
static inline void cs_rx_shut_blk(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_RXBLK_SHUT);
+ sc_ep_set(cs, SE_FL_RXBLK_SHUT);
}
/* Returns non-zero if the conn-stream's Tx path is blocked */
static inline int cs_tx_blocked(const struct conn_stream *cs)
{
- return !!sc_ep_test(cs, CS_EP_WAIT_DATA);
+ return !!sc_ep_test(cs, SE_FL_WAIT_DATA);
}
/* Returns non-zero if the conn-stream's endpoint is ready to transmit */
static inline int cs_tx_endp_ready(const struct conn_stream *cs)
{
- return sc_ep_test(cs, CS_EP_WANT_GET);
+ return sc_ep_test(cs, SE_FL_WANT_GET);
}
/* Report that a conn-stream wants to get some data from the output buffer */
static inline void cs_want_get(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_WANT_GET);
+ sc_ep_set(cs, SE_FL_WANT_GET);
}
/* Report that a conn-stream failed to get some data from the output buffer */
static inline void cs_cant_get(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_WANT_GET | CS_EP_WAIT_DATA);
+ sc_ep_set(cs, SE_FL_WANT_GET | SE_FL_WAIT_DATA);
}
/* Report that a conn-stream doesn't want to get data from the output buffer */
static inline void cs_stop_get(struct conn_stream *cs)
{
- sc_ep_clr(cs, CS_EP_WANT_GET);
+ sc_ep_clr(cs, SE_FL_WANT_GET);
}
/* Report that a conn-stream won't get any more data from the output buffer */
static inline void cs_done_get(struct conn_stream *cs)
{
- sc_ep_clr(cs, CS_EP_WANT_GET | CS_EP_WAIT_DATA);
+ sc_ep_clr(cs, SE_FL_WANT_GET | SE_FL_WAIT_DATA);
}
#endif /* _HAPROXY_CONN_STREAM_H */
* channel_alloc_buffer() for this so it abides by its rules. It returns 0 on
* failure, non-zero otherwise. If no buffer is available, the requester,
* represented by the <wait> pointer, will be added in the list of objects
- * waiting for an available buffer, and CS_EP_RXBLK_BUFF will be set on the
- * conn-stream and CS_EP_RX_WAIT_EP cleared. The requester will be responsible
+ * waiting for an available buffer, and SE_FL_RXBLK_BUFF will be set on the
+ * conn-stream and SE_FL_RX_WAIT_EP cleared. The requester will be responsible
* for calling this function to try again once woken up.
*/
static inline int cs_alloc_ibuf(struct conn_stream *cs, struct buffer_wait *wait)
/* Marks on the conn-stream that next shutw must kill the whole connection */
static inline void cs_must_kill_conn(struct conn_stream *cs)
{
- sc_ep_set(cs, CS_EP_KILL_CONN);
+ sc_ep_set(cs, SE_FL_KILL_CONN);
}
*/
static inline void cs_chk_rcv(struct conn_stream *cs)
{
- if (sc_ep_test(cs, CS_EP_RXBLK_CONN) && cs_state_in(cs_opposite(cs)->state, CS_SB_RDY|CS_SB_EST|CS_SB_DIS|CS_SB_CLO))
+ if (sc_ep_test(cs, SE_FL_RXBLK_CONN) && cs_state_in(cs_opposite(cs)->state, CS_SB_RDY|CS_SB_EST|CS_SB_DIS|CS_SB_CLO))
cs_rx_conn_rdy(cs);
if (cs_rx_blocked(cs) || !cs_rx_endp_ready(cs))
if (!cs_state_in(cs->state, CS_SB_RDY|CS_SB_EST))
return;
- sc_ep_set(cs, CS_EP_RX_WAIT_EP);
+ sc_ep_set(cs, SE_FL_RX_WAIT_EP);
cs->ops->chk_rcv(cs);
}
qcs->endp->target = qcs;
qcs->endp->conn = qcc->conn;
- se_fl_set(qcs->endp, CS_EP_T_MUX | CS_EP_ORPHAN | CS_EP_NOT_FIRST);
+ se_fl_set(qcs->endp, SE_FL_T_MUX | SE_FL_ORPHAN | SE_FL_NOT_FIRST);
/* TODO duplicated from mux_h2 */
sess->t_idle = tv_ms_elapsed(&sess->tv_accept, &now) - sess->t_handshake;
if (!endp)
goto fail_endp;
endp->target = appctx;
- se_fl_set(endp, CS_EP_T_APPLET | CS_EP_ORPHAN);
+ se_fl_set(endp, SE_FL_T_APPLET | SE_FL_ORPHAN);
}
appctx->endp = endp;
/* async startup is only possible for frontend appctx. Thus for orphan
* appctx. Because no backend appctx can be orphan.
*/
- BUG_ON(!se_fl_test(appctx->endp, CS_EP_ORPHAN));
+ BUG_ON(!se_fl_test(appctx->endp, SE_FL_ORPHAN));
sess = session_new(px, NULL, &appctx->obj_type);
if (!sess)
/* If a frontend apctx is attached to a conn-stream, release the stream
* instead of the appctx.
*/
- if (!se_fl_test(appctx->endp, CS_EP_ORPHAN) && !(appctx_cs(appctx)->flags & CS_FL_ISBACK)) {
+ if (!se_fl_test(appctx->endp, SE_FL_ORPHAN) && !(appctx_cs(appctx)->flags & CS_FL_ISBACK)) {
stream_free(appctx_strm(appctx));
return;
}
*/
void appctx_shut(struct appctx *appctx)
{
- if (se_fl_test(appctx->endp, CS_EP_SHR | CS_EP_SHW))
+ if (se_fl_test(appctx->endp, SE_FL_SHR | SE_FL_SHW))
return;
if (appctx->applet->release)
appctx->applet->release(appctx);
- se_fl_set(appctx->endp, CS_EP_SHRR | CS_EP_SHWN);
+ se_fl_set(appctx->endp, SE_FL_SHRR | SE_FL_SHWN);
}
/* Callback used to wake up an applet when a buffer is available. The applet
struct conn_stream *cs = appctx_cs(appctx);
/* allocation requested ? */
- if (!se_fl_test(appctx->endp, CS_EP_RXBLK_BUFF))
+ if (!se_fl_test(appctx->endp, SE_FL_RXBLK_BUFF))
return 0;
cs_rx_buff_rdy(cs);
return NULL;
}
- if (se_fl_test(app->endp, CS_EP_ORPHAN)) {
+ if (se_fl_test(app->endp, SE_FL_ORPHAN)) {
/* Finalize init of orphan appctx. .init callback function must
* be defined and it must finalize appctx startup.
*/
/* measure the call rate and check for anomalies when too high */
rate = update_freq_ctr(&app->call_rate, 1);
if (rate >= 100000 && app->call_rate.prev_ctr && // looped more than 100k times over last second
- ((b_size(cs_ib(cs)) && se_fl_test(app->endp, CS_EP_RXBLK_BUFF)) || // asks for a buffer which is present
- (b_size(cs_ib(cs)) && !b_data(cs_ib(cs)) && se_fl_test(app->endp, CS_EP_RXBLK_ROOM)) || // asks for room in an empty buffer
+ ((b_size(cs_ib(cs)) && se_fl_test(app->endp, SE_FL_RXBLK_BUFF)) || // asks for a buffer which is present
+ (b_size(cs_ib(cs)) && !b_data(cs_ib(cs)) && se_fl_test(app->endp, SE_FL_RXBLK_ROOM)) || // asks for room in an empty buffer
(b_data(cs_ob(cs)) && cs_tx_endp_ready(cs) && !cs_tx_blocked(cs)) || // asks for data already present
(!b_data(cs_ib(cs)) && b_data(cs_ob(cs)) && // didn't return anything ...
(cs_oc(cs)->flags & (CF_WRITE_PARTIAL|CF_SHUTW_NOW)) == CF_SHUTW_NOW))) { // ... and left data pending after a shut
srv_conn = NULL;
if (cs_reset_endp(s->csb) < 0)
return SF_ERR_INTERNAL;
- sc_ep_clr(s->csb, ~CS_EP_DETACHED);
+ sc_ep_clr(s->csb, ~SE_FL_DETACHED);
}
}
else
* loopback on a heavily loaded system.
*/
if (srv_conn->flags & CO_FL_ERROR)
- sc_ep_set(s->csb, CS_EP_ERROR);
+ sc_ep_set(s->csb, SE_FL_ERROR);
/* If we had early data, and the handshake ended, then
* we can remove the flag, and attempt to wake the task up,
* the handshake.
*/
if (!(srv_conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS)))
- sc_ep_clr(s->csb, CS_EP_WAIT_FOR_HS);
+ sc_ep_clr(s->csb, SE_FL_WAIT_FOR_HS);
if (!cs_state_in(s->csb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO) &&
(srv_conn->flags & CO_FL_WAIT_XPRT) == 0) {
* wake callback. Otherwise si_cs_recv()/si_cs_send() already take
* care of it.
*/
- if (sc_ep_test(s->csb, CS_EP_EOI) && !(cs_ic(s->csb)->flags & CF_EOI))
+ if (sc_ep_test(s->csb, SE_FL_EOI) && !(cs_ic(s->csb)->flags & CF_EOI))
cs_ic(s->csb)->flags |= (CF_EOI|CF_READ_PARTIAL);
/* catch all sync connect while the mux is not already installed */
* allocation problem, so we want to retry now.
*/
cs->state = CS_ST_CER;
- sc_ep_clr(cs, CS_EP_ERROR);
+ sc_ep_clr(cs, SE_FL_ERROR);
back_handle_st_cer(s);
DBG_TRACE_STATE("connection error, retry", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
done:
/* retryable error ? */
- if ((s->flags & SF_CONN_EXP) || sc_ep_test(cs, CS_EP_ERROR)) {
+ if ((s->flags & SF_CONN_EXP) || sc_ep_test(cs, SE_FL_ERROR)) {
if (!s->conn_err_type) {
- if (sc_ep_test(cs, CS_EP_ERROR))
+ if (sc_ep_test(cs, SE_FL_ERROR))
s->conn_err_type = STRM_ET_CONN_ERR;
else
s->conn_err_type = STRM_ET_CONN_TO;
void back_handle_st_cer(struct stream *s)
{
struct conn_stream *cs = s->csb;
- int must_tar = sc_ep_test(cs, CS_EP_ERROR);
+ int must_tar = sc_ep_test(cs, SE_FL_ERROR);
DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
_HA_ATOMIC_DEC(&__objt_server(s->target)->cur_sess);
}
- if (sc_ep_test(cs, CS_EP_ERROR) &&
+ if (sc_ep_test(cs, SE_FL_ERROR) &&
conn && conn->err_code == CO_ER_SSL_MISMATCH_SNI) {
/* We tried to connect to a server which is configured
* with "verify required" and which doesn't have the
* layers in an unexpected state (i.e < ST_CONN).
*
* Note: the conn-stream will be switched to ST_REQ, ST_ASS or
- * ST_TAR and CS_EP_ERROR and SF_CONN_EXP flags will be unset.
+ * ST_TAR and SE_FL_ERROR and SF_CONN_EXP flags will be unset.
*/
if (cs_reset_endp(cs) < 0) {
if (!s->conn_err_type)
}
/* retryable error ? */
- if (sc_ep_test(cs, CS_EP_ERROR)) {
+ if (sc_ep_test(cs, SE_FL_ERROR)) {
if (!s->conn_err_type)
s->conn_err_type = STRM_ET_CONN_ERR;
cs->state = CS_ST_CER;
/* no more data are expected. */
res_htx->flags |= HTX_FL_EOM;
res->flags |= CF_EOI;
- se_fl_set(appctx->endp, CS_EP_EOI);
+ se_fl_set(appctx->endp, SE_FL_EOI);
appctx->st0 = HTX_CACHE_END;
}
retrieve_errno_from_socket(conn);
if (conn && !(conn->flags & CO_FL_ERROR) &&
- cs && !sc_ep_test(cs, CS_EP_ERROR) && !expired)
+ cs && !sc_ep_test(cs, SE_FL_ERROR) && !expired)
return;
TRACE_ENTER(CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check, 0, 0, (size_t[]){expired});
}
else if (conn->flags & CO_FL_WAIT_L4_CONN) {
/* L4 not established (yet) */
- if (conn->flags & CO_FL_ERROR || sc_ep_test(cs, CS_EP_ERROR))
+ if (conn->flags & CO_FL_ERROR || sc_ep_test(cs, SE_FL_ERROR))
set_server_check_status(check, HCHK_STATUS_L4CON, err_msg);
else if (expired)
set_server_check_status(check, HCHK_STATUS_L4TOUT, err_msg);
}
else if (conn->flags & CO_FL_WAIT_L6_CONN) {
/* L6 not established (yet) */
- if (conn->flags & CO_FL_ERROR || sc_ep_test(cs, CS_EP_ERROR))
+ if (conn->flags & CO_FL_ERROR || sc_ep_test(cs, SE_FL_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 || sc_ep_test(cs, CS_EP_ERROR)) {
+ else if (conn->flags & CO_FL_ERROR || sc_ep_test(cs, SE_FL_ERROR)) {
/* I/O error after connection was established and before we could diagnose */
set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
}
cs = check->cs;
conn = cs_conn(cs);
- if (unlikely(!conn || !cs || conn->flags & CO_FL_ERROR || sc_ep_test(cs, CS_EP_ERROR))) {
+ if (unlikely(!conn || !cs || conn->flags & CO_FL_ERROR || sc_ep_test(cs, SE_FL_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
/* Here the connection must be defined. Otherwise the
* error would have already been detected
*/
- if ((conn && ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, CS_EP_ERROR))) || expired) {
+ if ((conn && ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_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);
}
conn = NULL;
if (!cs_reset_endp(check->cs)) {
/* error will be handled by tcpcheck_main().
- * On success, remove all flags except CS_EP_DETACHED
+ * On success, remove all flags except SE_FL_DETACHED
*/
- sc_ep_clr(check->cs, ~CS_EP_DETACHED);
+ sc_ep_clr(check->cs, ~SE_FL_DETACHED);
}
tcpcheck_main(check);
}
}
break;
default: /* abnormal state */
- se_fl_set(appctx->endp, CS_EP_ERROR);
+ se_fl_set(appctx->endp, SE_FL_ERROR);
break;
}
s->srv_error(s, s->csb);
return 1;
}
- se_fl_clr(s->csb->endp, ~CS_EP_DETACHED);
+ se_fl_clr(s->csb->endp, ~SE_FL_DETACHED);
}
sockaddr_free(&s->csb->dst);
endp->target = NULL;
endp->conn = NULL;
endp->cs = NULL;
- se_fl_setall(endp, CS_EP_NONE);
+ se_fl_setall(endp, SE_FL_NONE);
}
/* Tries to alloc an endpoint and initialize it. Returns NULL on failure. */
/* Tries to allocate a new conn_stream and initialize its main fields. On
* failure, nothing is allocated and NULL is returned. It is an internal
- * function. The caller must, at least, set the CS_EP_ORPHAN or CS_EP_DETACHED
+ * function. The caller must, at least, set the SE_FL_ORPHAN or SE_FL_DETACHED
* flag.
*/
static struct conn_stream *cs_new(struct cs_endpoint *endp)
/* Creates a new conn-stream and its associated stream from a mux. <endp> must be
* defined. It returns NULL on error. On success, the new conn-stream is
- * returned. In this case, CS_EP_ORPHAN flag is removed.
+ * returned. In this case, SE_FL_ORPHAN flag is removed.
*/
struct conn_stream *cs_new_from_endp(struct cs_endpoint *endp, struct session *sess, struct buffer *input)
{
pool_free(pool_head_connstream, cs);
cs = NULL;
}
- se_fl_clr(endp, CS_EP_ORPHAN);
+ se_fl_clr(endp, SE_FL_ORPHAN);
return cs;
}
/* Creates a new conn-stream from an stream. There is no endpoint here, thus it
- * will be created by cs_new(). So the CS_EP_DETACHED flag is set. It returns
+ * will be created by cs_new(). So the SE_FL_DETACHED flag is set. It returns
* NULL on error. On success, the new conn-stream is returned.
*/
struct conn_stream *cs_new_from_strm(struct stream *strm, unsigned int flags)
if (unlikely(!cs))
return NULL;
cs->flags |= flags;
- sc_ep_set(cs, CS_EP_DETACHED);
+ sc_ep_set(cs, SE_FL_DETACHED);
cs->app = &strm->obj_type;
cs->ops = &cs_app_embedded_ops;
cs->data_cb = NULL;
}
/* Creates a new conn-stream from an health-check. There is no endpoint here,
- * thus it will be created by cs_new(). So the CS_EP_DETACHED flag is set. It
+ * thus it will be created by cs_new(). So the SE_FL_DETACHED flag is set. It
* returns NULL on error. On success, the new conn-stream is returned.
*/
struct conn_stream *cs_new_from_check(struct check *check, unsigned int flags)
if (unlikely(!cs))
return NULL;
cs->flags |= flags;
- sc_ep_set(cs, CS_EP_DETACHED);
+ sc_ep_set(cs, SE_FL_DETACHED);
cs->app = &check->obj_type;
cs->data_cb = &check_conn_cb;
return cs;
sockaddr_free(&cs->src);
sockaddr_free(&cs->dst);
if (cs->endp) {
- BUG_ON(!sc_ep_test(cs, CS_EP_DETACHED));
+ BUG_ON(!sc_ep_test(cs, SE_FL_DETACHED));
cs_endpoint_free(cs->endp);
}
if (cs->wait_event.tasklet)
{
struct conn_stream *cs = *csp;
- if (!cs->app && (!cs->endp || sc_ep_test(cs, CS_EP_DETACHED))) {
+ if (!cs->app && (!cs->endp || sc_ep_test(cs, SE_FL_DETACHED))) {
cs_free(cs);
*csp = NULL;
}
/* Attaches a conn_stream to a mux endpoint and sets the endpoint ctx. Returns
- * -1 on error and 0 on sucess. CS_EP_DETACHED flag is removed. This function is
+ * -1 on error and 0 on sucess. SE_FL_DETACHED flag is removed. This function is
* called from a mux when it is attached to a stream or a health-check.
*/
int cs_attach_mux(struct conn_stream *cs, void *target, void *ctx)
cs->endp->target = target;
cs->endp->conn = ctx;
- sc_ep_set(cs, CS_EP_T_MUX);
- sc_ep_clr(cs, CS_EP_DETACHED);
+ sc_ep_set(cs, SE_FL_T_MUX);
+ sc_ep_clr(cs, SE_FL_DETACHED);
if (!conn->ctx)
conn->ctx = cs;
if (cs_strm(cs)) {
}
/* Attaches a conn_stream to an applet endpoint and sets the endpoint
- * ctx. Returns -1 on error and 0 on sucess. CS_EP_DETACHED flag is
+ * ctx. Returns -1 on error and 0 on sucess. SE_FL_DETACHED flag is
* removed. This function is called by a stream when a backend applet is
* registered.
*/
static void cs_attach_applet(struct conn_stream *cs, void *target)
{
cs->endp->target = target;
- sc_ep_set(cs, CS_EP_T_APPLET);
- sc_ep_clr(cs, CS_EP_DETACHED);
+ sc_ep_set(cs, SE_FL_T_APPLET);
+ sc_ep_clr(cs, SE_FL_DETACHED);
if (cs_strm(cs)) {
cs->ops = &cs_app_applet_ops;
cs->data_cb = &cs_data_applet_cb;
}
/* Attaches a conn_stream to a app layer and sets the relevant
- * callbacks. Returns -1 on error and 0 on success. CS_EP_ORPHAN flag is
+ * callbacks. Returns -1 on error and 0 on success. SE_FL_ORPHAN flag is
* removed. This function is called by a stream when it is created to attach it
* on the conn-stream on the client side.
*/
int cs_attach_strm(struct conn_stream *cs, struct stream *strm)
{
cs->app = &strm->obj_type;
- sc_ep_clr(cs, CS_EP_ORPHAN);
- if (sc_ep_test(cs, CS_EP_T_MUX)) {
+ sc_ep_clr(cs, SE_FL_ORPHAN);
+ if (sc_ep_test(cs, SE_FL_T_MUX)) {
cs->wait_event.tasklet = tasklet_new();
if (!cs->wait_event.tasklet)
return -1;
cs->ops = &cs_app_conn_ops;
cs->data_cb = &cs_data_conn_cb;
}
- else if (sc_ep_test(cs, CS_EP_T_APPLET)) {
+ else if (sc_ep_test(cs, SE_FL_T_APPLET)) {
cs->ops = &cs_app_applet_ops;
cs->data_cb = &cs_data_applet_cb;
}
if (!cs->endp)
goto reset_cs;
- if (sc_ep_test(cs, CS_EP_T_MUX)) {
+ if (sc_ep_test(cs, SE_FL_T_MUX)) {
struct connection *conn = __cs_conn(cs);
struct cs_endpoint *endp = cs->endp;
if (conn->mux) {
if (cs->wait_event.events != 0)
conn->mux->unsubscribe(cs, cs->wait_event.events, &cs->wait_event);
- se_fl_set(endp, CS_EP_ORPHAN);
+ se_fl_set(endp, SE_FL_ORPHAN);
endp->cs = NULL;
cs->endp = NULL;
conn->mux->detach(endp);
conn_free(conn);
}
}
- else if (sc_ep_test(cs, CS_EP_T_APPLET)) {
+ else if (sc_ep_test(cs, SE_FL_T_APPLET)) {
struct appctx *appctx = __cs_appctx(cs);
- sc_ep_set(cs, CS_EP_ORPHAN);
+ sc_ep_set(cs, SE_FL_ORPHAN);
cs->endp->cs = NULL;
cs->endp = NULL;
appctx_shut(appctx);
/* the cs is the only one one the endpoint */
cs->endp->target = NULL;
cs->endp->conn = NULL;
- sc_ep_clr(cs, ~CS_EP_APP_MASK);
- sc_ep_set(cs, CS_EP_DETACHED);
+ sc_ep_clr(cs, ~SE_FL_APP_MASK);
+ sc_ep_set(cs, SE_FL_DETACHED);
}
reset_cs:
* its endpoint. For a connection retry for instance. If a mux or an applet is
* attached, a new endpoint is created. Returns -1 on error and 0 on sucess.
*
- * Only CS_EP_ERROR flag is removed on the endpoint. Orther flags are preserved.
+ * Only SE_FL_ERROR flag is removed on the endpoint. Orther flags are preserved.
* It is the caller responsibility to remove other flags if needed.
*/
int cs_reset_endp(struct conn_stream *cs)
BUG_ON(!cs->app);
- sc_ep_clr(cs, CS_EP_ERROR);
+ sc_ep_clr(cs, SE_FL_ERROR);
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
* fails */
new_endp = cs_endpoint_new();
if (!unlikely(new_endp)) {
- sc_ep_set(cs, CS_EP_ERROR);
+ sc_ep_set(cs, SE_FL_ERROR);
return -1;
}
- se_fl_setall(new_endp, sc_ep_get(cs) & CS_EP_APP_MASK);
+ se_fl_setall(new_endp, sc_ep_get(cs) & SE_FL_APP_MASK);
/* The app is still attached, the cs will not be released */
cs_detach_endp(&cs);
BUG_ON(cs->endp);
cs->endp = new_endp;
cs->endp->cs = cs;
- sc_ep_set(cs, CS_EP_DETACHED);
+ sc_ep_set(cs, SE_FL_DETACHED);
return 0;
}
* However, if CS_FL_NOLINGER is explicitly set, we know there is
* no risk so we close both sides immediately.
*/
- if (!sc_ep_test(cs, CS_EP_ERROR) && !(cs->flags & CS_FL_NOLINGER) &&
+ if (!sc_ep_test(cs, SE_FL_ERROR) && !(cs->flags & CS_FL_NOLINGER) &&
!(ic->flags & (CF_SHUTR|CF_DONT_READ)))
return;
if (unlikely(cs->state != CS_ST_EST || (oc->flags & CF_SHUTW)))
return;
- if (!sc_ep_test(cs, CS_EP_WAIT_DATA) || /* not waiting for data */
+ if (!sc_ep_test(cs, SE_FL_WAIT_DATA) || /* not waiting for data */
channel_is_empty(oc)) /* called with nothing to send ! */
return;
/* Otherwise there are remaining data to be sent in the buffer,
* so we tell the handler.
*/
- sc_ep_clr(cs, CS_EP_WAIT_DATA);
+ sc_ep_clr(cs, SE_FL_WAIT_DATA);
if (!tick_isset(oc->wex))
oc->wex = tick_add_ifset(now_ms, oc->wto);
* no risk so we close both sides immediately.
*/
- if (sc_ep_test(cs, CS_EP_ERROR)) {
+ if (sc_ep_test(cs, SE_FL_ERROR)) {
/* quick close, the socket is already shut anyway */
}
else if (cs->flags & CS_FL_NOLINGER) {
return;
if (!oc->pipe && /* spliced data wants to be forwarded ASAP */
- !sc_ep_test(cs, CS_EP_WAIT_DATA)) /* not waiting for data */
+ !sc_ep_test(cs, SE_FL_WAIT_DATA)) /* not waiting for data */
return;
if (!(cs->wait_event.events & SUB_RETRY_SEND) && !channel_is_empty(cs_oc(cs)))
cs_conn_send(cs);
- if (sc_ep_test(cs, CS_EP_ERROR | CS_EP_ERR_PENDING) || cs_is_conn_error(cs)) {
+ if (sc_ep_test(cs, SE_FL_ERROR | SE_FL_ERR_PENDING) || cs_is_conn_error(cs)) {
/* Write error on the file descriptor */
if (cs->state >= CS_ST_CON)
- sc_ep_set(cs, CS_EP_ERROR);
+ sc_ep_set(cs, SE_FL_ERROR);
goto out_wakeup;
}
}
if ((oc->flags & (CF_SHUTW|CF_SHUTW_NOW)) == 0)
- sc_ep_set(cs, CS_EP_WAIT_DATA);
+ sc_ep_set(cs, SE_FL_WAIT_DATA);
oc->wex = TICK_ETERNITY;
}
else {
/* Otherwise there are remaining data to be sent in the buffer,
* which means we have to poll before doing so.
*/
- sc_ep_clr(cs, CS_EP_WAIT_DATA);
+ sc_ep_clr(cs, SE_FL_WAIT_DATA);
if (!tick_isset(oc->wex))
oc->wex = tick_add_ifset(now_ms, oc->wto);
}
* However, if CS_FL_NOLINGER is explicitly set, we know there is
* no risk so we close both sides immediately.
*/
- if (!sc_ep_test(cs, CS_EP_ERROR) && !(cs->flags & CS_FL_NOLINGER) &&
+ if (!sc_ep_test(cs, SE_FL_ERROR) && !(cs->flags & CS_FL_NOLINGER) &&
!(ic->flags & (CF_SHUTR|CF_DONT_READ)))
return;
/* we only wake the applet up if it was waiting for some data */
- if (!sc_ep_test(cs, CS_EP_WAIT_DATA))
+ if (!sc_ep_test(cs, SE_FL_WAIT_DATA))
return;
if (!tick_isset(oc->wex))
*/
cs_rx_room_rdy(cs);
}
- if (sc_ep_test(cs, CS_EP_RXBLK_ANY))
+ if (sc_ep_test(cs, SE_FL_RXBLK_ANY))
ic->rex = TICK_ETERNITY;
else if (!(ic->flags & CF_READ_NOEXP) && !tick_isset(ic->rex))
ic->rex = tick_add_ifset(now_ms, ic->rto);
/* Write not closed, update FD status and timeout for writes */
if (channel_is_empty(oc)) {
/* stop writing */
- if (!sc_ep_test(cs, CS_EP_WAIT_DATA)) {
+ if (!sc_ep_test(cs, SE_FL_WAIT_DATA)) {
if ((oc->flags & CF_SHUTW_NOW) == 0)
- sc_ep_set(cs, CS_EP_WAIT_DATA);
+ sc_ep_set(cs, SE_FL_WAIT_DATA);
oc->wex = TICK_ETERNITY;
}
return;
* update it if is was not yet set. The stream socket handler will already
* have updated it if there has been a completed I/O.
*/
- sc_ep_clr(cs, CS_EP_WAIT_DATA);
+ sc_ep_clr(cs, SE_FL_WAIT_DATA);
if (!tick_isset(oc->wex)) {
oc->wex = tick_add_ifset(now_ms, oc->wto);
if (tick_isset(ic->rex) && !(cs->flags & CS_FL_INDEP_STR)) {
* layers (applets, connections) after I/O completion. After updating the stream
* interface and timeouts, it will try to forward what can be forwarded, then to
* wake the associated task up if an important event requires special handling.
- * It may update CS_EP_WAIT_DATA and/or CS_EP_RXBLK_ROOM, that the callers are
+ * It may update SE_FL_WAIT_DATA and/or SE_FL_RXBLK_ROOM, that the callers are
* encouraged to watch to take appropriate action.
* It should not be called from within the stream itself, cs_update()
* is designed for this.
* we're about to close and can't expect more data if SHUTW_NOW is there.
*/
if (!(oc->flags & (CF_SHUTW|CF_SHUTW_NOW)))
- sc_ep_set(cs, CS_EP_WAIT_DATA);
+ sc_ep_set(cs, SE_FL_WAIT_DATA);
else if ((oc->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW)
- sc_ep_clr(cs, CS_EP_WAIT_DATA);
+ sc_ep_clr(cs, SE_FL_WAIT_DATA);
/* update OC timeouts and wake the other side up if it's waiting for room */
if (oc->flags & CF_WRITE_ACTIVITY) {
* are output data, but we avoid doing this if some of the data are
* not yet scheduled for being forwarded, because it is very likely
* that it will be done again immediately afterwards once the following
- * data are parsed (eg: HTTP chunking). We only CS_EP_RXBLK_ROOM once
+ * data are parsed (eg: HTTP chunking). We only SE_FL_RXBLK_ROOM once
* we've emptied *some* of the output buffer, and not just when there
* is available room, because applets are often forced to stop before
* the buffer is full. We must not stop based on input data alone because
* an HTTP parser might need more data to complete the parsing.
*/
if (!channel_is_empty(ic) &&
- sc_ep_test(cso, CS_EP_WAIT_DATA) &&
+ sc_ep_test(cso, SE_FL_WAIT_DATA) &&
(!(ic->flags & CF_EXPECT_MORE) || c_full(ic) || ci_data(ic) == 0 || ic->pipe)) {
int new_len, last_len;
if (/* changes on the production side */
(ic->flags & (CF_READ_NULL|CF_READ_ERROR)) ||
!cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST) ||
- sc_ep_test(cs, CS_EP_ERROR) ||
+ sc_ep_test(cs, SE_FL_ERROR) ||
((ic->flags & CF_READ_PARTIAL) &&
((ic->flags & CF_EOI) || !ic->to_forward || cso->state != CS_ST_EST)) ||
return 0;
/* stop here if we reached the end of data */
- if (sc_ep_test(cs, CS_EP_EOS))
+ if (sc_ep_test(cs, SE_FL_EOS))
goto end_recv;
/* stop immediately on errors. Note that we DON'T want to stop on
* happens when we send too large a request to a backend server
* which rejects it before reading it all.
*/
- if (!sc_ep_test(cs, CS_EP_RCV_MORE)) {
+ if (!sc_ep_test(cs, SE_FL_RCV_MORE)) {
if (!conn_xprt_ready(conn))
return 0;
- if (sc_ep_test(cs, CS_EP_ERROR))
+ if (sc_ep_test(cs, SE_FL_ERROR))
goto end_recv;
}
/* prepare to detect if the mux needs more room */
- sc_ep_clr(cs, CS_EP_WANT_ROOM);
+ sc_ep_clr(cs, SE_FL_WANT_ROOM);
if ((ic->flags & (CF_STREAMER | CF_STREAMER_FAST)) && !co_data(ic) &&
global.tune.idle_timer &&
/* First, let's see if we may splice data across the channel without
* using a buffer.
*/
- if (sc_ep_test(cs, CS_EP_MAY_SPLICE) &&
+ if (sc_ep_test(cs, SE_FL_MAY_SPLICE) &&
(ic->pipe || ic->to_forward >= MIN_SPLICE_FORWARD) &&
ic->flags & CF_KERN_SPLICING) {
if (c_data(ic)) {
ic->flags |= CF_READ_PARTIAL;
}
- if (sc_ep_test(cs, CS_EP_EOS | CS_EP_ERROR))
+ if (sc_ep_test(cs, SE_FL_EOS | SE_FL_ERROR))
goto end_recv;
if (conn->flags & CO_FL_WAIT_ROOM) {
ic->pipe = NULL;
}
- if (ic->pipe && ic->to_forward && !(flags & CO_RFL_BUF_FLUSH) && sc_ep_test(cs, CS_EP_MAY_SPLICE)) {
+ if (ic->pipe && ic->to_forward && !(flags & CO_RFL_BUF_FLUSH) && sc_ep_test(cs, SE_FL_MAY_SPLICE)) {
/* don't break splicing by reading, but still call rcv_buf()
* to pass the flag.
*/
* that if such an event is not handled above in splice, it will be handled here by
* recv().
*/
- while (sc_ep_test(cs, CS_EP_RCV_MORE) ||
+ while (sc_ep_test(cs, SE_FL_RCV_MORE) ||
(!(conn->flags & CO_FL_HANDSHAKE) &&
- (!sc_ep_test(cs, CS_EP_ERROR | CS_EP_EOS)) && !(ic->flags & CF_SHUTR))) {
+ (!sc_ep_test(cs, SE_FL_ERROR | SE_FL_EOS)) && !(ic->flags & CF_SHUTR))) {
int cur_flags = flags;
/* Compute transient CO_RFL_* flags */
}
/* <max> may be null. This is the mux responsibility to set
- * CS_EP_RCV_MORE on the CS if more space is needed.
+ * SE_FL_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 (sc_ep_test(cs, CS_EP_WANT_ROOM)) {
- /* CS_EP_WANT_ROOM must not be reported if the channel's
+ if (sc_ep_test(cs, SE_FL_WANT_ROOM)) {
+ /* SE_FL_WANT_ROOM must not be reported if the channel's
* buffer is empty.
*/
BUG_ON(c_empty(ic));
* the channel's policies.This way, we are still able to receive
* shutdowns.
*/
- if (sc_ep_test(cs, CS_EP_EOI))
+ if (sc_ep_test(cs, SE_FL_EOI))
break;
if ((ic->flags & CF_READ_DONTWAIT) || --read_poll <= 0) {
/* Report EOI on the channel if it was reached from the mux point of
* view. */
- if (sc_ep_test(cs, CS_EP_EOI) && !(ic->flags & CF_EOI)) {
+ if (sc_ep_test(cs, SE_FL_EOI) && !(ic->flags & CF_EOI)) {
ic->flags |= (CF_EOI|CF_READ_PARTIAL);
ret = 1;
}
- if (sc_ep_test(cs, CS_EP_ERROR))
+ if (sc_ep_test(cs, SE_FL_ERROR))
ret = 1;
- else if (sc_ep_test(cs, CS_EP_EOS)) {
+ else if (sc_ep_test(cs, SE_FL_EOS)) {
/* we received a shutdown */
ic->flags |= CF_READ_NULL;
if (ic->flags & CF_AUTO_CLOSE)
int ret;
int did_send = 0;
- if (sc_ep_test(cs, CS_EP_ERROR | CS_EP_ERR_PENDING) || cs_is_conn_error(cs)) {
+ if (sc_ep_test(cs, SE_FL_ERROR | SE_FL_ERR_PENDING) || cs_is_conn_error(cs)) {
/* We're probably there because the tasklet was woken up,
* but process_stream() ran before, detected there were an
* error and put the CS back to CS_ST_TAR. There's still
* CO_FL_ERROR on the connection but we don't want to add
- * CS_EP_ERROR back, so give up
+ * SE_FL_ERROR back, so give up
*/
if (cs->state < CS_ST_CON)
return 0;
- sc_ep_set(cs, CS_EP_ERROR);
+ sc_ep_set(cs, SE_FL_ERROR);
return 1;
}
cs_rx_room_rdy(cs_opposite(cs));
}
- if (sc_ep_test(cs, CS_EP_ERROR | CS_EP_ERR_PENDING)) {
- sc_ep_set(cs, CS_EP_ERROR);
+ if (sc_ep_test(cs, SE_FL_ERROR | SE_FL_ERR_PENDING)) {
+ sc_ep_set(cs, SE_FL_ERROR);
return 1;
}
/* First step, report to the conn-stream what was detected at the
* connection layer : errors and connection establishment.
- * Only add CS_EP_ERROR if we're connected, or we're attempting to
+ * Only add SE_FL_ERROR if we're connected, or we're attempting to
* connect, we may get there because we got woken up, but only run
* after process_stream() noticed there were an error, and decided
* to retry to connect, the connection may still have CO_FL_ERROR,
- * and we don't want to add CS_EP_ERROR back
+ * and we don't want to add SE_FL_ERROR back
*
* Note: This test is only required because cs_conn_process is also the SI
* wake callback. Otherwise cs_conn_recv()/cs_conn_send() already take
if (cs->state >= CS_ST_CON) {
if (cs_is_conn_error(cs))
- sc_ep_set(cs, CS_EP_ERROR);
+ sc_ep_set(cs, SE_FL_ERROR);
}
/* If we had early data, and the handshake ended, then
* the handshake.
*/
if (!(conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS)) &&
- sc_ep_test(cs, CS_EP_WAIT_FOR_HS)) {
- sc_ep_clr(cs, CS_EP_WAIT_FOR_HS);
+ sc_ep_test(cs, SE_FL_WAIT_FOR_HS)) {
+ sc_ep_clr(cs, SE_FL_WAIT_FOR_HS);
task_wakeup(cs_strm_task(cs), TASK_WOKEN_MSG);
}
* wake callback. Otherwise cs_conn_recv()/cs_conn_send() already take
* care of it.
*/
- if (sc_ep_test(cs, CS_EP_EOS) && !(ic->flags & CF_SHUTR)) {
+ if (sc_ep_test(cs, SE_FL_EOS) && !(ic->flags & CF_SHUTR)) {
/* we received a shutdown */
ic->flags |= CF_READ_NULL;
if (ic->flags & CF_AUTO_CLOSE)
* wake callback. Otherwise cs_conn_recv()/cs_conn_send() already take
* care of it.
*/
- if (sc_ep_test(cs, CS_EP_EOI) && !(ic->flags & CF_EOI))
+ if (sc_ep_test(cs, SE_FL_EOI) && !(ic->flags & CF_EOI))
ic->flags |= (CF_EOI|CF_READ_PARTIAL);
/* Second step : update the conn-stream and channels, try to forward any
/* If the applet wants to write and the channel is closed, it's a
* broken pipe and it must be reported.
*/
- if (!sc_ep_test(cs, CS_EP_RX_WAIT_EP) && (ic->flags & CF_SHUTR))
- sc_ep_set(cs, CS_EP_ERROR);
+ if (!sc_ep_test(cs, SE_FL_RX_WAIT_EP) && (ic->flags & CF_SHUTR))
+ sc_ep_set(cs, SE_FL_ERROR);
/* automatically mark the applet having data available if it reported
* begin blocked by the channel.
res_htx->flags |= HTX_FL_EOM;
res->flags |= CF_EOI;
- se_fl_set(ctx->endp, CS_EP_EOI);
+ se_fl_set(ctx->endp, SE_FL_EOI);
strm->txn->status = http_ctx->status;
http_ctx->flags |= APPLET_RSP_SENT;
}
s->flags |= SF_ERR_INTERNAL;
return -1;
}
- sc_ep_clr(cs, CS_EP_RXBLK_SHUT);
+ sc_ep_clr(cs, SE_FL_RXBLK_SHUT);
b_free(&req->buf);
/* Swap the L7 buffer with the channel buffer */
return NULL;
s->txn = txn;
- txn->flags = ((cs && sc_ep_test(cs, CS_EP_NOT_FIRST)) ? TX_NOT_FIRST : 0);
+ txn->flags = ((cs && sc_ep_test(cs, SE_FL_NOT_FIRST)) ? TX_NOT_FIRST : 0);
txn->status = -1;
txn->http_reply = NULL;
txn->l7_buffer = BUF_NULL;
if (htx->flags & HTX_FL_EOM) {
req->flags |= CF_EOI;
se_fl_set(appctx->endp,
- CS_EP_EOI);
+ SE_FL_EOI);
appctx->st0 = HTTPCLIENT_S_RES_STLINE;
}
/* a dummy closed endpoint */
static const struct cs_endpoint closed_ep = {
. cs = NULL,
- .flags = CS_EP_DETACHED,
+ .flags = SE_FL_DETACHED,
};
/* a dmumy management stream */
if (!fstrm->id)
fstrm->fconn->nb_reserved--;
if (fstrm->endp->cs) {
- if (!se_fl_test(fstrm->endp, CS_EP_EOS) && !b_data(&fstrm->rxbuf))
+ if (!se_fl_test(fstrm->endp, SE_FL_EOS) && !b_data(&fstrm->rxbuf))
fcgi_strm_notify_recv(fstrm);
}
fstrm->state = FCGI_SS_CLOSED;
*/
LIST_DEL_INIT(&fstrm->send_list);
tasklet_free(fstrm->shut_tl);
- BUG_ON(fstrm->endp && !se_fl_test(fstrm->endp, CS_EP_ORPHAN));
+ BUG_ON(fstrm->endp && !se_fl_test(fstrm->endp, SE_FL_ORPHAN));
cs_endpoint_free(fstrm->endp);
pool_free(pool_head_fcgi_strm, fstrm);
return NULL;
}
-/* 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
+/* Wakes a specific stream and assign its conn_stream some SE_FL_* flags among
+ * SE_FL_ERR_PENDING and SE_FL_ERROR if needed. The stream's state is
* automatically updated accordingly. If the stream is orphaned, it is
* destroyed.
*/
}
if ((fconn->state == FCGI_CS_CLOSED || fconn->conn->flags & CO_FL_ERROR)) {
- se_fl_set(fstrm->endp, CS_EP_ERR_PENDING);
- if (se_fl_test(fstrm->endp, CS_EP_EOS))
- se_fl_set(fstrm->endp, CS_EP_ERROR);
+ se_fl_set(fstrm->endp, SE_FL_ERR_PENDING);
+ if (se_fl_test(fstrm->endp, SE_FL_EOS))
+ se_fl_set(fstrm->endp, SE_FL_ERROR);
if (fstrm->state < FCGI_SS_ERROR) {
fstrm->state = FCGI_SS_ERROR;
fcgi_conn_read0_pending(fconn) ||
fstrm->state == FCGI_SS_CLOSED ||
(fstrm->flags & FCGI_SF_ES_RCVD) ||
- se_fl_test(fstrm->endp, CS_EP_ERROR | CS_EP_ERR_PENDING | CS_EP_EOS))) {
+ se_fl_test(fstrm->endp, SE_FL_ERROR | SE_FL_ERR_PENDING | SE_FL_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);
- se_fl_set(fstrm->endp, CS_EP_RCV_MORE);
+ se_fl_set(fstrm->endp, SE_FL_RCV_MORE);
fcgi_strm_notify_recv(fstrm);
}
fstrm = tmp_fstrm;
fcgi_conn_read0_pending(fconn) ||
fstrm->state == FCGI_SS_CLOSED ||
(fstrm->flags & FCGI_SF_ES_RCVD) ||
- se_fl_test(fstrm->endp, CS_EP_ERROR | CS_EP_ERR_PENDING | CS_EP_EOS))) {
+ se_fl_test(fstrm->endp, SE_FL_ERROR | SE_FL_ERR_PENDING | SE_FL_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);
- se_fl_set(fstrm->endp, CS_EP_RCV_MORE);
+ se_fl_set(fstrm->endp, SE_FL_RCV_MORE);
fcgi_strm_notify_recv(fstrm);
}
while (node) {
fstrm = container_of(node, struct fcgi_strm, by_id);
- if (fstrm->endp->cs && se_fl_test(fstrm->endp, CS_EP_WAIT_FOR_HS))
+ if (fstrm->endp->cs && se_fl_test(fstrm->endp, SE_FL_WAIT_FOR_HS))
fcgi_strm_notify_recv(fstrm);
node = eb32_next(node);
}
* for example because of a "tcp-request content reject" rule that is
* normally used to limit abuse.
*/
- if (se_fl_test(fstrm->endp, CS_EP_KILL_CONN) &&
+ if (se_fl_test(fstrm->endp, SE_FL_KILL_CONN) &&
!(fconn->flags & (FCGI_CF_ABRTS_SENT|FCGI_CF_ABRTS_FAILED))) {
TRACE_STATE("stream wants to kill the connection", FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
fconn->state = FCGI_CS_CLOSED;
* for example because of a "tcp-request content reject" rule that is
* normally used to limit abuse.
*/
- if (se_fl_test(fstrm->endp, CS_EP_KILL_CONN) &&
+ if (se_fl_test(fstrm->endp, SE_FL_KILL_CONN) &&
!(fconn->flags & (FCGI_CF_ABRTS_SENT|FCGI_CF_ABRTS_FAILED))) {
TRACE_STATE("stream wants to kill the connection", FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
fconn->state = FCGI_CS_CLOSED;
TRACE_STATE("fstrm rxbuf not allocated", FCGI_EV_STRM_RECV|FCGI_EV_FSTRM_BLK, fconn->conn, fstrm);
if (b_data(&fstrm->rxbuf))
- se_fl_set(fstrm->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_set(fstrm->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
else {
- se_fl_clr(fstrm->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_clr(fstrm->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
if (fstrm->state == FCGI_SS_ERROR || (fstrm->h1m.state == H1_MSG_DONE)) {
- se_fl_set(fstrm->endp, CS_EP_EOI);
+ se_fl_set(fstrm->endp, SE_FL_EOI);
if (!(fstrm->h1m.flags & (H1_MF_VER_11|H1_MF_XFER_LEN)))
- se_fl_set(fstrm->endp, CS_EP_EOS);
+ se_fl_set(fstrm->endp, SE_FL_EOS);
}
if (fcgi_conn_read0_pending(fconn))
- se_fl_set(fstrm->endp, CS_EP_EOS);
- if (se_fl_test(fstrm->endp, CS_EP_ERR_PENDING))
- se_fl_set(fstrm->endp, CS_EP_ERROR);
+ se_fl_set(fstrm->endp, SE_FL_EOS);
+ if (se_fl_test(fstrm->endp, SE_FL_ERR_PENDING))
+ se_fl_set(fstrm->endp, SE_FL_ERROR);
fcgi_release_buf(fconn, &fstrm->rxbuf);
}
if (id < 0) {
fcgi_strm_close(fstrm);
- se_fl_set(fstrm->endp, CS_EP_ERROR);
+ se_fl_set(fstrm->endp, SE_FL_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;
}
fstrm->endp->cs);
if (fstrm->endp) {
chunk_appendf(msg, " .endp.flg=0x%08x", se_fl_get(fstrm->endp));
- if (!se_fl_test(fstrm->endp, CS_EP_ORPHAN))
+ if (!se_fl_test(fstrm->endp, SE_FL_ORPHAN))
chunk_appendf(msg, " .cs.flg=0x%08x .cs.app=%p",
fstrm->endp->cs->flags, fstrm->endp->cs->app);
}
TRACE_ENTER(H1_EV_STRM_NEW, h1c->conn, h1s);
if (h1s->flags & H1S_F_NOT_FIRST)
- se_fl_set(h1s->endp, CS_EP_NOT_FIRST);
+ se_fl_set(h1s->endp, SE_FL_NOT_FIRST);
if (h1s->req.flags & H1_MF_UPG_WEBSOCKET)
- se_fl_set(h1s->endp, CS_EP_WEBSOCKET);
+ se_fl_set(h1s->endp, SE_FL_WEBSOCKET);
if (!cs_new_from_endp(h1s->endp, h1c->conn->owner, input)) {
TRACE_ERROR("CS allocation failure", H1_EV_STRM_NEW|H1_EV_STRM_END|H1_EV_STRM_ERR, h1c->conn, h1s);
goto fail;
h1s->endp->target = h1s;
h1s->endp->conn = h1c->conn;
- se_fl_set(h1s->endp, CS_EP_T_MUX | CS_EP_ORPHAN);
+ se_fl_set(h1s->endp, SE_FL_T_MUX | SE_FL_ORPHAN);
}
h1s->sess = sess;
}
HA_ATOMIC_DEC(&h1c->px_counters->open_streams);
- BUG_ON(h1s->endp && !se_fl_test(h1s->endp, CS_EP_ORPHAN));
+ BUG_ON(h1s->endp && !se_fl_test(h1s->endp, SE_FL_ORPHAN));
cs_endpoint_free(h1s->endp);
pool_free(pool_head_h1s, h1s);
}
/* Here h1s->endp->cs is always defined */
if (!(h1m->flags & H1_MF_CHNK) && (h1m->state == H1_MSG_DATA || (h1m->state == H1_MSG_TUNNEL))) {
TRACE_STATE("notify the mux can use splicing", H1_EV_RX_DATA|H1_EV_RX_BODY, h1c->conn, h1s);
- se_fl_set(h1s->endp, CS_EP_MAY_SPLICE);
+ se_fl_set(h1s->endp, SE_FL_MAY_SPLICE);
}
else {
TRACE_STATE("notify the mux can't use splicing anymore", H1_EV_RX_DATA|H1_EV_RX_BODY, h1c->conn, h1s);
- se_fl_clr(h1s->endp, CS_EP_MAY_SPLICE);
+ se_fl_clr(h1s->endp, SE_FL_MAY_SPLICE);
}
/* Set EOI on conn-stream in DONE state iff:
*/
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)))
- se_fl_set(h1s->endp, CS_EP_EOI);
+ se_fl_set(h1s->endp, SE_FL_EOI);
out:
/* When Input data are pending for this message, notify upper layer that
* - Headers or trailers are pending to be copied.
*/
if (h1s->flags & (H1S_F_RX_CONGESTED)) {
- se_fl_set(h1s->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_set(h1s->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
TRACE_STATE("waiting for more room", H1_EV_RX_DATA|H1_EV_H1S_BLK, h1c->conn, h1s);
}
else {
- se_fl_clr(h1s->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_clr(h1s->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
if (h1s->flags & H1S_F_REOS) {
- se_fl_set(h1s->endp, CS_EP_EOS);
+ se_fl_set(h1s->endp, SE_FL_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 */
- se_fl_set(h1s->endp, CS_EP_EOI);
+ se_fl_set(h1s->endp, SE_FL_EOI);
}
else if (h1m->state > H1_MSG_LAST_LF && h1m->state < H1_MSG_DONE) {
- se_fl_set(h1s->endp, CS_EP_ERROR);
+ se_fl_set(h1s->endp, SE_FL_ERROR);
TRACE_ERROR("message aborted, set error on CS", H1_EV_RX_DATA|H1_EV_H1S_ERR, h1c->conn, h1s);
}
err:
htx_to_buf(htx, buf);
- se_fl_set(h1s->endp, CS_EP_EOI);
+ se_fl_set(h1s->endp, SE_FL_EOI);
TRACE_DEVEL("leaving on error", H1_EV_RX_DATA|H1_EV_STRM_ERR, h1c->conn, h1s);
return 0;
}
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);
}
- se_fl_set(h1s->endp, CS_EP_EOI);
+ se_fl_set(h1s->endp, SE_FL_EOI);
}
TRACE_LEAVE(H1_EV_TX_DATA, h1c->conn, h1s, chn_htx, (size_t[]){total});
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)))
- se_fl_set(h1s->endp, CS_EP_ERROR);
+ se_fl_set(h1s->endp, SE_FL_ERROR);
TRACE_POINT(H1_EV_STRM_WAKE, h1c->conn, h1s);
h1_alert(h1s);
}
BUG_ON(!h1s || h1c->flags & H1C_F_ST_READY);
if (conn_xprt_read0_pending(conn) || (h1s->flags & H1S_F_REOS))
- se_fl_set(h1s->endp, CS_EP_EOS);
+ se_fl_set(h1s->endp, SE_FL_EOS);
if ((h1c->flags & H1C_F_ST_ERROR) || (conn->flags & CO_FL_ERROR))
- se_fl_set(h1s->endp, CS_EP_ERROR);
+ se_fl_set(h1s->endp, SE_FL_ERROR);
h1_alert(h1s);
TRACE_DEVEL("waiting to release the CS before releasing the connection", H1_EV_H1C_WAKE);
}
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 */
- se_fl_set(h1c->h1s->endp, CS_EP_EOS | CS_EP_ERROR);
+ se_fl_set(h1c->h1s->endp, SE_FL_EOS | SE_FL_ERROR);
h1_alert(h1c->h1s);
h1_refresh_timeout(h1c);
HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conns[tid].idle_conns_lock);
TRACE_ENTER(H1_EV_STRM_SHUT, h1c->conn, h1s, 0, (size_t[]){mode});
- if (se_fl_test(h1s->endp, CS_EP_SHR))
+ if (se_fl_test(h1s->endp, SE_FL_SHR))
goto end;
- if (se_fl_test(h1s->endp, CS_EP_KILL_CONN)) {
+ if (se_fl_test(h1s->endp, SE_FL_KILL_CONN)) {
TRACE_STATE("stream wants to kill the connection", H1_EV_STRM_SHUT, h1c->conn, h1s);
goto do_shutr;
}
do_shutr:
/* NOTE: Be sure to handle abort (cf. h2_shutr) */
- if (se_fl_test(h1s->endp, CS_EP_SHR))
+ if (se_fl_test(h1s->endp, SE_FL_SHR))
goto end;
if (conn_xprt_ready(h1c->conn) && h1c->conn->xprt->shutr)
TRACE_ENTER(H1_EV_STRM_SHUT, h1c->conn, h1s, 0, (size_t[]){mode});
- if (se_fl_test(h1s->endp, CS_EP_SHW))
+ if (se_fl_test(h1s->endp, SE_FL_SHW))
goto end;
- if (se_fl_test(h1s->endp, CS_EP_KILL_CONN)) {
+ if (se_fl_test(h1s->endp, SE_FL_KILL_CONN)) {
TRACE_STATE("stream wants to kill the connection", H1_EV_STRM_SHUT, h1c->conn, h1s);
goto do_shutw;
}
else
TRACE_DEVEL("h1c ibuf not allocated", H1_EV_H1C_RECV|H1_EV_H1C_BLK, h1c->conn);
- if ((flags & CO_RFL_BUF_FLUSH) && se_fl_test(h1s->endp, CS_EP_MAY_SPLICE)) {
+ if ((flags & CO_RFL_BUF_FLUSH) && se_fl_test(h1s->endp, SE_FL_MAY_SPLICE)) {
h1c->flags |= H1C_F_WANT_SPLICE;
TRACE_STATE("Block xprt rcv_buf to flush stream's buffer (want_splice)", H1_EV_STRM_RECV, h1c->conn, h1s);
}
}
if (h1c->flags & H1C_F_ST_ERROR) {
- se_fl_set(h1s->endp, CS_EP_ERROR);
+ se_fl_set(h1s->endp, SE_FL_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;
}
}
if (h1c->flags & H1C_F_ST_ERROR) {
- se_fl_set(h1s->endp, CS_EP_ERROR);
+ se_fl_set(h1s->endp, SE_FL_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);
}
if (ret > h1m->curr_len) {
h1s->flags |= H1S_F_PARSING_ERROR;
h1c->flags |= H1C_F_ST_ERROR;
- se_fl_set(h1s->endp, CS_EP_ERROR);
+ se_fl_set(h1s->endp, SE_FL_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;
if (!(h1c->flags & H1C_F_WANT_SPLICE)) {
TRACE_STATE("notify the mux can't use splicing anymore", H1_EV_STRM_RECV, h1c->conn, h1s);
- se_fl_clr(h1s->endp, CS_EP_MAY_SPLICE);
+ se_fl_clr(h1s->endp, SE_FL_MAY_SPLICE);
if (!(h1c->wait_event.events & SUB_RETRY_RECV)) {
TRACE_STATE("restart receiving data, subscribing", H1_EV_STRM_RECV, h1c->conn, h1s);
h1c->conn->xprt->subscribe(h1c->conn, h1c->conn->xprt_ctx, SUB_RETRY_RECV, &h1c->wait_event);
if (ret > h1m->curr_len) {
h1s->flags |= H1S_F_PROCESSING_ERROR;
h1c->flags |= H1C_F_ST_ERROR;
- se_fl_set(h1s->endp, CS_EP_ERROR);
+ se_fl_set(h1s->endp, SE_FL_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;
if (h1s->endp) {
chunk_appendf(msg, " .endp.flg=0x%08x",
se_fl_get(h1s->endp));
- if (!se_fl_test(h1s->endp, CS_EP_ORPHAN))
+ if (!se_fl_test(h1s->endp, SE_FL_ORPHAN))
chunk_appendf(msg, " .cs.flg=0x%08x .cs.app=%p",
h1s->endp->cs->flags, h1s->endp->cs->app);
}
/* a dummy closed endpoint */
static const struct cs_endpoint closed_ep = {
. cs = NULL,
- .flags = CS_EP_DETACHED,
+ .flags = SE_FL_DETACHED,
};
/* a dmumy closed stream */
if (!h2s->id)
h2s->h2c->nb_reserved--;
if (h2s->endp->cs) {
- if (!se_fl_test(h2s->endp, CS_EP_EOS) && !b_data(&h2s->rxbuf))
+ if (!se_fl_test(h2s->endp, SE_FL_EOS) && !b_data(&h2s->rxbuf))
h2s_notify_recv(h2s);
}
HA_ATOMIC_DEC(&h2s->h2c->px_counters->open_streams);
/* ditto, calling tasklet_free() here should be ok */
tasklet_free(h2s->shut_tl);
- BUG_ON(h2s->endp && !se_fl_test(h2s->endp, CS_EP_ORPHAN));
+ BUG_ON(h2s->endp && !se_fl_test(h2s->endp, SE_FL_ORPHAN));
cs_endpoint_free(h2s->endp);
pool_free(pool_head_h2s, h2s);
goto out_close;
h2s->endp->target = h2s;
h2s->endp->conn = h2c->conn;
- se_fl_set(h2s->endp, CS_EP_T_MUX | CS_EP_ORPHAN | CS_EP_NOT_FIRST);
+ se_fl_set(h2s->endp, SE_FL_T_MUX | SE_FL_ORPHAN | SE_FL_NOT_FIRST);
/* FIXME wrong analogy between ext-connect and websocket, this need to
* be refine.
*/
if (flags & H2_SF_EXT_CONNECT_RCVD)
- se_fl_set(h2s->endp, CS_EP_WEBSOCKET);
+ se_fl_set(h2s->endp, SE_FL_WEBSOCKET);
/* The stream will record the request's accept date (which is either the
* end of the connection's or the date immediately after the previous
return ret;
}
-/* 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
+/* wake a specific stream and assign its conn_stream some SE_FL_* flags among
+ * SE_FL_ERR_PENDING and SE_FL_ERROR if needed. The stream's state
* is automatically updated accordingly. If the stream is orphaned, it is
* destroyed.
*/
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))) {
- se_fl_set(h2s->endp, CS_EP_ERR_PENDING);
- if (se_fl_test(h2s->endp, CS_EP_EOS))
- se_fl_set(h2s->endp, CS_EP_ERROR);
+ se_fl_set(h2s->endp, SE_FL_ERR_PENDING);
+ if (se_fl_test(h2s->endp, SE_FL_EOS))
+ se_fl_set(h2s->endp, SE_FL_ERROR);
if (h2s->st < H2_SS_ERROR)
h2s->st = H2_SS_ERROR;
if (h2c->dff & H2_F_HEADERS_END_STREAM)
h2s->flags |= H2_SF_ES_RCVD;
- if (se_fl_test(h2s->endp, CS_EP_ERROR) && h2s->st < H2_SS_ERROR)
+ if (se_fl_test(h2s->endp, SE_FL_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)
h2c_read0_pending(h2c) ||
h2s->st == H2_SS_CLOSED ||
(h2s->flags & H2_SF_ES_RCVD) ||
- se_fl_test(h2s->endp, CS_EP_ERROR | CS_EP_ERR_PENDING | CS_EP_EOS))) {
+ se_fl_test(h2s->endp, SE_FL_ERROR | SE_FL_ERR_PENDING | SE_FL_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);
- se_fl_set(h2s->endp, CS_EP_RCV_MORE);
+ se_fl_set(h2s->endp, SE_FL_RCV_MORE);
h2s_notify_recv(h2s);
}
h2s = tmp_h2s;
h2c_read0_pending(h2c) ||
h2s->st == H2_SS_CLOSED ||
(h2s->flags & H2_SF_ES_RCVD) ||
- se_fl_test(h2s->endp, CS_EP_ERROR | CS_EP_ERR_PENDING | CS_EP_EOS))) {
+ se_fl_test(h2s->endp, SE_FL_ERROR | SE_FL_ERR_PENDING | SE_FL_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);
- se_fl_set(h2s->endp, CS_EP_RCV_MORE);
+ se_fl_set(h2s->endp, SE_FL_RCV_MORE);
h2s_notify_recv(h2s);
}
while (node) {
h2s = container_of(node, struct h2s, by_id);
- if (se_fl_test(h2s->endp, CS_EP_WAIT_FOR_HS))
+ if (se_fl_test(h2s->endp, SE_FL_WAIT_FOR_HS))
h2s_notify_recv(h2s);
node = eb32_next(node);
}
* normally used to limit abuse. In this case we schedule a goaway to
* close the connection.
*/
- if (se_fl_test(h2s->endp, CS_EP_KILL_CONN) &&
+ if (se_fl_test(h2s->endp, SE_FL_KILL_CONN) &&
!(h2c->flags & (H2_CF_GOAWAY_SENT|H2_CF_GOAWAY_FAILED))) {
TRACE_STATE("stream wants to kill the connection", H2_EV_STRM_SHUT, h2c->conn, h2s);
h2c_error(h2c, H2_ERR_ENHANCE_YOUR_CALM);
* normally used to limit abuse. In this case we schedule a goaway to
* close the connection.
*/
- if (se_fl_test(h2s->endp, CS_EP_KILL_CONN) &&
+ if (se_fl_test(h2s->endp, SE_FL_KILL_CONN) &&
!(h2c->flags & (H2_CF_GOAWAY_SENT|H2_CF_GOAWAY_FAILED))) {
TRACE_STATE("stream wants to kill the connection", H2_EV_STRM_SHUT, h2c->conn, h2s);
h2c_error(h2c, H2_ERR_ENHANCE_YOUR_CALM);
/* 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_EP_RCV_MORE must be checked to know if some data remain pending (an empty
+ * SE_FL_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
break;
}
- if (!h2s->endp->cs || se_fl_test(h2s->endp, CS_EP_SHW)) {
+ if (!h2s->endp->cs || se_fl_test(h2s->endp, SE_FL_SHW)) {
/* Response already closed: add END_STREAM */
es_now = 1;
}
break;
}
- if (!h2s->endp->cs || se_fl_test(h2s->endp, CS_EP_SHW)) {
+ if (!h2s->endp->cs || se_fl_test(h2s->endp, SE_FL_SHW)) {
/* Request already closed: add END_STREAM */
es_now = 1;
}
if (h2s_htx->flags & HTX_FL_PARSING_ERROR) {
buf_htx->flags |= HTX_FL_PARSING_ERROR;
if (htx_is_empty(buf_htx))
- se_fl_set(h2s->endp, CS_EP_EOI);
+ se_fl_set(h2s->endp, SE_FL_EOI);
}
else if (htx_is_empty(h2s_htx))
buf_htx->flags |= (h2s_htx->flags & HTX_FL_EOM);
end:
if (b_data(&h2s->rxbuf))
- se_fl_set(h2s->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_set(h2s->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
else {
- se_fl_clr(h2s->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_clr(h2s->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
if (h2s->flags & H2_SF_ES_RCVD) {
- se_fl_set(h2s->endp, CS_EP_EOI);
+ se_fl_set(h2s->endp, SE_FL_EOI);
/* Add EOS flag for tunnel */
if (h2s->flags & H2_SF_BODY_TUNNEL)
- se_fl_set(h2s->endp, CS_EP_EOS);
+ se_fl_set(h2s->endp, SE_FL_EOS);
}
if (h2c_read0_pending(h2c) || h2s->st == H2_SS_CLOSED)
- se_fl_set(h2s->endp, CS_EP_EOS);
- if (se_fl_test(h2s->endp, CS_EP_ERR_PENDING))
- se_fl_set(h2s->endp, CS_EP_ERROR);
+ se_fl_set(h2s->endp, SE_FL_EOS);
+ if (se_fl_test(h2s->endp, SE_FL_ERR_PENDING))
+ se_fl_set(h2s->endp, SE_FL_ERROR);
if (b_size(&h2s->rxbuf)) {
b_free(&h2s->rxbuf);
offer_buffers(NULL, 1);
}
if (h2s->h2c->st0 >= H2_CS_ERROR) {
- se_fl_set(h2s->endp, CS_EP_ERROR);
+ se_fl_set(h2s->endp, SE_FL_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;
}
int32_t id = h2c_get_next_sid(h2s->h2c);
if (id < 0) {
- se_fl_set(h2s->endp, CS_EP_ERROR);
+ se_fl_set(h2s->endp, SE_FL_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;
}
!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 (se_fl_test(h2s->endp, CS_EP_EOS))
- se_fl_set(h2s->endp, CS_EP_ERROR);
+ if (se_fl_test(h2s->endp, SE_FL_EOS))
+ se_fl_set(h2s->endp, SE_FL_ERROR);
else
- se_fl_set(h2s->endp, CS_EP_ERR_PENDING);
+ se_fl_set(h2s->endp, SE_FL_ERR_PENDING);
}
if (total > 0 && !(h2s->flags & H2_SF_BLK_SFCTL) &&
if (conn && ctx->wait_event.events != 0)
conn->xprt->unsubscribe(conn, conn->xprt_ctx, ctx->wait_event.events,
&ctx->wait_event);
- BUG_ON(ctx->endp && !se_fl_test(ctx->endp, CS_EP_ORPHAN));
+ BUG_ON(ctx->endp && !se_fl_test(ctx->endp, SE_FL_ORPHAN));
cs_endpoint_free(ctx->endp);
pool_free(pool_head_pt_ctx, ctx);
struct mux_pt_ctx *ctx = tctx;
TRACE_ENTER(PT_EV_CONN_WAKE, ctx->conn);
- if (!se_fl_test(ctx->endp, CS_EP_ORPHAN)) {
+ if (!se_fl_test(ctx->endp, SE_FL_ORPHAN)) {
/* There's a small race condition.
* mux_pt_io_cb() is only supposed to be called if we have no
* stream attached. However, maybe the tasklet got woken up,
}
ctx->endp->target = ctx;
ctx->endp->conn = conn;
- se_fl_set(ctx->endp, CS_EP_T_MUX | CS_EP_ORPHAN);
+ se_fl_set(ctx->endp, SE_FL_T_MUX | SE_FL_ORPHAN);
cs = cs_new_from_endp(ctx->endp, sess, input);
if (!cs) {
ctx->endp = cs->endp;
}
conn->ctx = ctx;
- se_fl_set(ctx->endp, CS_EP_RCV_MORE);
+ se_fl_set(ctx->endp, SE_FL_RCV_MORE);
if (global.tune.options & GTUNE_USE_SPLICE)
- se_fl_set(ctx->endp, CS_EP_MAY_SPLICE);
+ se_fl_set(ctx->endp, SE_FL_MAY_SPLICE);
TRACE_LEAVE(PT_EV_CONN_NEW, conn);
return 0;
int ret = 0;
TRACE_ENTER(PT_EV_CONN_WAKE, ctx->conn);
- if (!se_fl_test(ctx->endp, CS_EP_ORPHAN)) {
+ if (!se_fl_test(ctx->endp, SE_FL_ORPHAN)) {
ret = ctx->endp->cs->data_cb->wake ? ctx->endp->cs->data_cb->wake(ctx->endp->cs) : 0;
if (ret < 0) {
if (cs_attach_mux(endp->cs, ctx, conn) < 0)
return -1;
ctx->endp = endp;
- se_fl_set(ctx->endp, CS_EP_RCV_MORE);
+ se_fl_set(ctx->endp, SE_FL_RCV_MORE);
TRACE_LEAVE(PT_EV_STRM_NEW, conn, endp->cs);
return 0;
struct mux_pt_ctx *pt = ctx;
TRACE_POINT(PT_EV_CONN_END, pt->conn, pt->endp->cs);
- if (se_fl_test(pt->endp, CS_EP_ORPHAN) || pt->conn->ctx != pt) {
+ if (se_fl_test(pt->endp, SE_FL_ORPHAN) || pt->conn->ctx != pt) {
if (pt->conn->ctx != pt) {
pt->endp = NULL;
}
{
struct mux_pt_ctx *ctx = conn->ctx;
- return (!se_fl_test(ctx->endp, CS_EP_ORPHAN) ? 1 : 0);
+ return (!se_fl_test(ctx->endp, SE_FL_ORPHAN) ? 1 : 0);
}
/* returns the number of streams still available on a connection */
TRACE_ENTER(PT_EV_STRM_SHUT, conn, cs);
- if (se_fl_test(ctx->endp, CS_EP_SHR))
+ if (se_fl_test(ctx->endp, SE_FL_SHR))
return;
- se_fl_clr(ctx->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_clr(ctx->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
if (conn_xprt_ready(conn) && conn->xprt->shutr)
conn->xprt->shutr(conn, conn->xprt_ctx,
(mode == CO_SHR_DRAIN));
else if (mode == CO_SHR_DRAIN)
conn_ctrl_drain(conn);
- if (se_fl_test(ctx->endp, CS_EP_SHW))
+ if (se_fl_test(ctx->endp, SE_FL_SHW))
conn_full_close(conn);
TRACE_LEAVE(PT_EV_STRM_SHUT, conn, cs);
TRACE_ENTER(PT_EV_STRM_SHUT, conn, cs);
- if (se_fl_test(ctx->endp, CS_EP_SHW))
+ if (se_fl_test(ctx->endp, SE_FL_SHW))
return;
if (conn_xprt_ready(conn) && conn->xprt->shutw)
conn->xprt->shutw(conn, conn->xprt_ctx,
(mode == CO_SHW_NORMAL));
- if (!se_fl_test(ctx->endp, CS_EP_SHR))
+ if (!se_fl_test(ctx->endp, SE_FL_SHR))
conn_sock_shutw(conn, (mode == CO_SHW_NORMAL));
else
conn_full_close(conn);
TRACE_ENTER(PT_EV_RX_DATA, conn, cs, buf, (size_t[]){count});
if (!count) {
- se_fl_set(ctx->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_set(ctx->endp, SE_FL_RCV_MORE | SE_FL_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)) {
- se_fl_clr(ctx->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
- se_fl_set(ctx->endp, CS_EP_EOS);
+ se_fl_clr(ctx->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
+ se_fl_set(ctx->endp, SE_FL_EOS);
TRACE_DEVEL("read0 on connection", PT_EV_RX_DATA, conn, cs);
}
if (conn->flags & CO_FL_ERROR) {
- se_fl_clr(ctx->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
- se_fl_set(ctx->endp, CS_EP_ERROR);
+ se_fl_clr(ctx->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
+ se_fl_set(ctx->endp, SE_FL_ERROR);
TRACE_DEVEL("error on connection", PT_EV_RX_DATA|PT_EV_CONN_ERR, conn, cs);
}
end:
b_del(buf, ret);
if (conn->flags & CO_FL_ERROR) {
- se_fl_set(ctx->endp, CS_EP_ERROR);
+ se_fl_set(ctx->endp, SE_FL_ERROR);
TRACE_DEVEL("error on connection", PT_EV_TX_DATA|PT_EV_CONN_ERR, conn, cs);
}
ret = conn->xprt->rcv_pipe(conn, conn->xprt_ctx, pipe, count);
if (conn_xprt_read0_pending(conn)) {
- se_fl_set(ctx->endp, CS_EP_EOS);
+ se_fl_set(ctx->endp, SE_FL_EOS);
TRACE_DEVEL("read0 on connection", PT_EV_RX_DATA, conn, cs);
}
if (conn->flags & CO_FL_ERROR) {
- se_fl_set(ctx->endp, CS_EP_ERROR);
+ se_fl_set(ctx->endp, SE_FL_ERROR);
TRACE_DEVEL("error on connection", PT_EV_RX_DATA|PT_EV_CONN_ERR, conn, cs);
}
ret = conn->xprt->snd_pipe(conn, conn->xprt_ctx, pipe);
if (conn->flags & CO_FL_ERROR) {
- se_fl_set(ctx->endp, CS_EP_ERROR);
+ se_fl_set(ctx->endp, SE_FL_ERROR);
TRACE_DEVEL("error on connection", PT_EV_TX_DATA|PT_EV_CONN_ERR, conn, cs);
}
qc_stream_desc_release(qcs->stream);
- BUG_ON(qcs->endp && !se_fl_test(qcs->endp, CS_EP_ORPHAN));
+ BUG_ON(qcs->endp && !se_fl_test(qcs->endp, SE_FL_ORPHAN));
cs_endpoint_free(qcs->endp);
eb64_delete(&qcs->by_id);
end:
if (b_data(&qcs->rx.app_buf)) {
- se_fl_set(qcs->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
+ se_fl_set(qcs->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
}
else {
- se_fl_clr(qcs->endp, CS_EP_RCV_MORE | CS_EP_WANT_ROOM);
- if (se_fl_test(qcs->endp, CS_EP_ERR_PENDING))
- se_fl_set(qcs->endp, CS_EP_ERROR);
+ se_fl_clr(qcs->endp, SE_FL_RCV_MORE | SE_FL_WANT_ROOM);
+ if (se_fl_test(qcs->endp, SE_FL_ERR_PENDING))
+ se_fl_set(qcs->endp, SE_FL_ERROR);
if (fin)
- se_fl_set(qcs->endp, CS_EP_EOI);
+ se_fl_set(qcs->endp, SE_FL_EOI);
if (b_size(&qcs->rx.app_buf)) {
b_free(&qcs->rx.app_buf);
}
/* Loop through all qcs from <qcc>. If CO_FL_ERROR is set on the connection,
- * report CS_EP_ERR_PENDING|CS_EP_ERROR on the attached conn-streams and wake
+ * report SE_FL_ERR_PENDING|SE_FL_ERROR on the attached conn-streams and wake
* them.
*/
static int qc_wake_some_streams(struct qcc *qcc)
continue;
if (qcc->conn->flags & CO_FL_ERROR) {
- se_fl_set(qcs->endp, CS_EP_ERR_PENDING);
- if (se_fl_test(qcs->endp, CS_EP_EOS))
- se_fl_set(qcs->endp, CS_EP_ERROR);
+ se_fl_set(qcs->endp, SE_FL_ERR_PENDING);
+ if (se_fl_test(qcs->endp, SE_FL_EOS))
+ se_fl_set(qcs->endp, SE_FL_ERROR);
if (qcs->subs) {
qcs_notify_recv(qcs);
if (conn && cs) {
if (conn->flags & (CO_FL_EARLY_SSL_HS | CO_FL_SSL_WAIT_HS)) {
- sc_ep_set(cs, CS_EP_WAIT_FOR_HS);
+ sc_ep_set(cs, SE_FL_WAIT_FOR_HS);
s->req.flags |= CF_READ_NULL;
return ACT_RET_YIELD;
}
}
res_htx->flags |= HTX_FL_EOM;
res->flags |= CF_EOI;
- se_fl_set(appctx->endp, CS_EP_EOI);
+ se_fl_set(appctx->endp, SE_FL_EOI);
appctx->st0 = STAT_HTTP_END;
}
/* Callback used to wake up a stream when an input buffer is available. The
* stream <s>'s conn-streams are checked for a failed buffer allocation
- * as indicated by the presence of the CS_EP_RXBLK_ROOM flag and the lack of a
+ * as indicated by the presence of the SE_FL_RXBLK_ROOM flag and the lack of a
* buffer, and and input buffer is assigned there (at most one). The function
* returns 1 and wakes the stream up if a buffer was taken, otherwise zero.
* It's designed to be called from __offer_buffer().
{
struct stream *s = arg;
- if (!s->req.buf.size && !s->req.pipe && sc_ep_test(s->csf, CS_EP_RXBLK_BUFF) &&
+ if (!s->req.buf.size && !s->req.pipe && sc_ep_test(s->csf, SE_FL_RXBLK_BUFF) &&
b_alloc(&s->req.buf))
cs_rx_buff_rdy(s->csf);
- else if (!s->res.buf.size && !s->res.pipe && sc_ep_test(s->csb, CS_EP_RXBLK_BUFF) &&
+ else if (!s->res.buf.size && !s->res.pipe && sc_ep_test(s->csb, SE_FL_RXBLK_BUFF) &&
b_alloc(&s->res.buf))
cs_rx_buff_rdy(s->csb);
else
if (likely(sess->fe->options2 & PR_O2_INDEPSTR))
s->csb->flags |= CS_FL_INDEP_STR;
- if (sc_ep_test(cs, CS_EP_WEBSOCKET))
+ if (sc_ep_test(cs, SE_FL_WEBSOCKET))
s->flags |= SF_WEBSOCKET;
if (cs_conn(cs)) {
const struct mux_ops *mux = cs_conn_mux(cs);
s->flags &= ~SF_CONN_EXP;
/* errors faced after sending data need to be reported */
- if (sc_ep_test(s->csb, CS_EP_ERROR) && req->flags & CF_WROTE_DATA) {
+ if (sc_ep_test(s->csb, SE_FL_ERROR) && req->flags & CF_WROTE_DATA) {
/* Don't add CF_WRITE_ERROR if we're here because
* early data were rejected by the server, or
* http_wait_for_response() will never be called
(CF_SHUTR|CF_READ_ACTIVITY|CF_READ_TIMEOUT|CF_SHUTW|
CF_WRITE_ACTIVITY|CF_WRITE_TIMEOUT|CF_ANA_TIMEOUT)) &&
!(s->flags & SF_CONN_EXP) &&
- !((sc_ep_get(csf) | csb->flags) & CS_EP_ERROR) &&
+ !((sc_ep_get(csf) | csb->flags) & SE_FL_ERROR) &&
((s->pending_events & TASK_WOKEN_ANY) == TASK_WOKEN_TIMER)) {
csf->flags &= ~CS_FL_DONT_WAKE;
csb->flags &= ~CS_FL_DONT_WAKE;
* must be be reviewed too.
*/
if (!stream_alloc_work_buffer(s)) {
- sc_ep_set(s->csf, CS_EP_ERROR);
+ sc_ep_set(s->csf, SE_FL_ERROR);
s->conn_err_type = STRM_ET_CONN_RES;
- sc_ep_set(s->csb, CS_EP_ERROR);
+ sc_ep_set(s->csb, SE_FL_ERROR);
s->conn_err_type = STRM_ET_CONN_RES;
if (!(s->flags & SF_ERR_MASK))
* connection setup code must be able to deal with any type of abort.
*/
srv = objt_server(s->target);
- if (unlikely(sc_ep_test(csf, CS_EP_ERROR))) {
+ if (unlikely(sc_ep_test(csf, SE_FL_ERROR))) {
if (cs_state_in(csf->state, CS_SB_EST|CS_SB_DIS)) {
cs_shutr(csf);
cs_shutw(csf);
}
}
- if (unlikely(sc_ep_test(csb, CS_EP_ERROR))) {
+ if (unlikely(sc_ep_test(csb, SE_FL_ERROR))) {
if (cs_state_in(csb->state, CS_SB_EST|CS_SB_DIS)) {
cs_shutr(csb);
cs_shutw(csb);
/* Benchmarks have shown that it's optimal to do a full resync now */
if (csf->state == CS_ST_DIS ||
cs_state_in(csb->state, CS_SB_RDY|CS_SB_DIS) ||
- (sc_ep_test(csf, CS_EP_ERROR) && csf->state != CS_ST_CLO) ||
- (sc_ep_test(csb, CS_EP_ERROR) && csb->state != CS_ST_CLO))
+ (sc_ep_test(csf, SE_FL_ERROR) && csf->state != CS_ST_CLO) ||
+ (sc_ep_test(csb, SE_FL_ERROR) && csb->state != CS_ST_CLO))
goto resync_conn_stream;
/* otherwise we want to check if we need to resync the req buffer or not */
if (csf->state == CS_ST_DIS ||
cs_state_in(csb->state, CS_SB_RDY|CS_SB_DIS) ||
- (sc_ep_test(csf, CS_EP_ERROR) && csf->state != CS_ST_CLO) ||
- (sc_ep_test(csb, CS_EP_ERROR) && csb->state != CS_ST_CLO))
+ (sc_ep_test(csf, SE_FL_ERROR) && csf->state != CS_ST_CLO) ||
+ (sc_ep_test(csb, SE_FL_ERROR) && csb->state != CS_ST_CLO))
goto resync_conn_stream;
if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER)
csf = strm->csf;
chunk_appendf(&trash, " csf=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
csf, csf->flags, cs_state_str(csf->state),
- (sc_ep_test(csf, CS_EP_T_MUX) ? "CONN" : (sc_ep_test(csf, CS_EP_T_APPLET) ? "APPCTX" : "NONE")),
- csf->endp->target, sc_ep_get(csf),
- csf->wait_event.events);
+ (sc_ep_test(csf, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(csf, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
+ csf->endp->target, sc_ep_get(csf), csf->wait_event.events);
if ((conn = cs_conn(csf)) != NULL) {
chunk_appendf(&trash,
csb = strm->csb;
chunk_appendf(&trash, " csb=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
csb, csb->flags, cs_state_str(csb->state),
- (sc_ep_test(csb, CS_EP_T_MUX) ? "CONN" : (sc_ep_test(csb, CS_EP_T_APPLET) ? "APPCTX" : "NONE")),
- csb->endp->target, sc_ep_get(csb),
- csb->wait_event.events);
+ (sc_ep_test(csb, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(csb, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
+ csb->endp->target, sc_ep_get(csb), csb->wait_event.events);
+
if ((conn = cs_conn(csb)) != NULL) {
chunk_appendf(&trash,
" co1=%p ctrl=%s xprt=%s mux=%s data=%s target=%s:%p\n",
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) || sc_ep_test(cs, CS_EP_ERROR)) {
+ if ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_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;
goto wait_more_data;
}
- if (sc_ep_test(cs, CS_EP_EOS))
+ if (sc_ep_test(cs, SE_FL_EOS))
goto end_recv;
if (check->state & CHK_ST_IN_ALLOC) {
/* errors on the connection and the conn-stream were already checked */
/* prepare to detect if the mux needs more room */
- sc_ep_clr(cs, CS_EP_WANT_ROOM);
+ sc_ep_clr(cs, SE_FL_WANT_ROOM);
- while (sc_ep_test(cs, CS_EP_RCV_MORE) ||
- (!(conn->flags & CO_FL_ERROR) && !sc_ep_test(cs, CS_EP_ERROR | CS_EP_EOS))) {
+ while (sc_ep_test(cs, SE_FL_RCV_MORE) ||
+ (!(conn->flags & CO_FL_ERROR) && !sc_ep_test(cs, SE_FL_ERROR | SE_FL_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 ||
- sc_ep_test(cs, CS_EP_WANT_ROOM) ||
+ sc_ep_test(cs, SE_FL_WANT_ROOM) ||
(--read_poll <= 0) ||
(read < max && read >= global.tune.recv_enough))
break;
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) || sc_ep_test(cs, CS_EP_ERROR))) {
+ if (is_empty && ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_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
goto stop;
}
if (!cur_read) {
- if (sc_ep_test(cs, CS_EP_EOI)) {
+ if (sc_ep_test(cs, SE_FL_EOI)) {
/* If EOI is set, it means there is a response or an error */
goto out;
}
- if (!sc_ep_test(cs, CS_EP_WANT_ROOM | CS_EP_ERROR | CS_EP_EOS)) {
+ if (!sc_ep_test(cs, SE_FL_WANT_ROOM | SE_FL_ERROR | SE_FL_EOS)) {
conn->mux->subscribe(cs, SUB_RETRY_RECV, &cs->wait_event);
TRACE_DEVEL("waiting for response", CHK_EV_RX_DATA, check);
goto wait_more_data;
*/
/* 1- check for connection error, if any */
- if ((conn && conn->flags & CO_FL_ERROR) || sc_ep_test(cs, CS_EP_ERROR))
+ if ((conn && conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR))
goto out_end_tcpcheck;
/* 2- check if a rule must be resume. It happens if check->current_step
goto out_end_tcpcheck;
else if (eval_ret == TCPCHK_EVAL_WAIT)
goto out;
- last_read = ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, CS_EP_ERROR | CS_EP_EOS));
+ last_read = ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR | SE_FL_EOS));
must_read = 0;
}
TRACE_PROTO("tcp-check passed", CHK_EV_TCPCHK_EVAL, check);
out_end_tcpcheck:
- if ((conn && conn->flags & CO_FL_ERROR) || sc_ep_test(cs, CS_EP_ERROR)) {
+ if ((conn && conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR)) {
TRACE_ERROR("report connection error", CHK_EV_TCPCHK_EVAL|CHK_EV_TCPCHK_ERR, check);
chk_report_conn_err(check, errno, 0);
}
projects / thirdparty / haproxy.git / commitdiff
