* performing some retries (eg: connection error). Some states are transient and
* do not last beyond process_session().
*/
-enum cs_state {
+enum sc_state {
SC_ST_INI = 0, /* CS not sollicitated yet */
SC_ST_REQ, /* [transient] connection initiation desired and not started yet */
SC_ST_QUE, /* CS waiting in queue */
} __attribute__((packed));
/* state bits for use with lists of states */
-enum cs_state_bit {
+enum sc_state_bit {
SC_SB_NONE = 0,
SC_SB_INI = 1U << SC_ST_INI,
SC_SB_REQ = 1U << SC_ST_REQ,
*/
struct stconn {
enum obj_type obj_type; /* differentiates connection from applet context */
- enum cs_state state; /* CS_ST* */
+ enum sc_state state; /* CS_ST* */
/* 2 bytes hole here */
unsigned int flags; /* SC_FL_* */
}
/* returns the stream connector on the other side. Used during forwarding. */
-static inline struct stconn *cs_opposite(const struct stconn *cs)
+static inline struct stconn *sc_opposite(const struct stconn *cs)
{
struct stream *strm = __sc_strm(cs);
/* to be called only when in SC_ST_DIS with SC_FL_ERR */
-static inline void cs_report_error(struct stconn *cs)
+static inline void sc_report_error(struct stconn *cs)
{
if (!__sc_strm(cs)->conn_err_type)
__sc_strm(cs)->conn_err_type = STRM_ET_DATA_ERR;
/* sets the current and previous state of a stream connector to <state>. This is
* mainly used to create one in the established state on incoming conncetions.
*/
-static inline void cs_set_state(struct stconn *cs, int state)
+static inline void sc_set_state(struct stconn *cs, int state)
{
cs->state = __sc_strm(cs)->prev_conn_state = state;
}
/* returns a bit for a stream connector state, to match against SC_SB_* */
-static inline enum cs_state_bit cs_state_bit(enum cs_state state)
+static inline enum sc_state_bit sc_state_bit(enum sc_state state)
{
BUG_ON(state > SC_ST_CLO);
return 1U << state;
}
/* returns true if <state> matches one of the SC_SB_* bits in <mask> */
-static inline int cs_state_in(enum cs_state state, enum cs_state_bit mask)
+static inline int sc_state_in(enum sc_state state, enum sc_state_bit mask)
{
BUG_ON(mask & ~SC_SB_ALL);
- return !!(cs_state_bit(state) & mask);
+ return !!(sc_state_bit(state) & mask);
}
/* Returns true if a connection is attached to the stream connector <cs> and if this
* may hold pending data. This function returns true if such an error was
* reported. Both the CS and the CONN must be valid.
*/
-static inline int cs_is_conn_error(const struct stconn *cs)
+static inline int sc_is_conn_error(const struct stconn *cs)
{
const struct connection *conn;
* stream connector and SE_FL_HAVE_NO_DATA cleared. The requester will be responsible
* for calling this function to try again once woken up.
*/
-static inline int cs_alloc_ibuf(struct stconn *cs, struct buffer_wait *wait)
+static inline int sc_alloc_ibuf(struct stconn *cs, struct buffer_wait *wait)
{
int ret;
static inline void sc_chk_rcv(struct stconn *cs)
{
if (sc_ep_test(cs, SE_FL_APPLET_NEED_CONN) &&
- cs_state_in(cs_opposite(cs)->state, SC_SB_RDY|SC_SB_EST|SC_SB_DIS|SC_SB_CLO))
+ sc_state_in(sc_opposite(cs)->state, SC_SB_RDY|SC_SB_EST|SC_SB_DIS|SC_SB_CLO))
sc_ep_clr(cs, SE_FL_APPLET_NEED_CONN);
if (!sc_is_recv_allowed(cs))
return;
- if (!cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST))
+ if (!sc_state_in(cs->state, SC_SB_RDY|SC_SB_EST))
return;
sc_ep_set(cs, SE_FL_HAVE_NO_DATA);
}
/* for debugging, reports the stream connector state name */
-static inline const char *cs_state_str(int state)
+static inline const char *sc_state_str(int state)
{
switch (state) {
case SC_ST_INI: return "INI";
int conn_retries; /* number of connect retries performed */
unsigned int conn_exp; /* wake up time for connect, queue, turn-around, ... */
unsigned int conn_err_type; /* first error detected, one of STRM_ET_* */
- enum cs_state prev_conn_state; /* CS_ST*, copy of previous state of the server stream connector */
+ enum sc_state prev_conn_state; /* CS_ST*, copy of previous state of the server stream connector */
struct list list; /* position in the thread's streams list */
struct mt_list by_srv; /* position in server stream list */
* some other processing if needed. The applet doesn't have anything to
* do if it needs the buffer, it will be called again upon readiness.
*/
- if (!cs_alloc_ibuf(cs, &app->buffer_wait))
+ if (!sc_alloc_ibuf(cs, &app->buffer_wait))
applet_have_more_data(app);
count = co_data(sc_oc(cs));
*/
if (count != co_data(sc_oc(cs))) {
sc_oc(cs)->flags |= CF_WRITE_PARTIAL | CF_WROTE_DATA;
- sc_have_room(cs_opposite(cs));
+ sc_have_room(sc_opposite(cs));
}
/* measure the call rate and check for anomalies when too high */
if (!(srv_conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS)))
sc_ep_clr(s->scb, SE_FL_WAIT_FOR_HS);
- if (!cs_state_in(s->scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
+ if (!sc_state_in(s->scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
(srv_conn->flags & CO_FL_WAIT_XPRT) == 0) {
s->conn_exp = TICK_ETERNITY;
sc_oc(s->scb)->flags |= CF_WRITE_NULL;
struct cmsghdr *cmsg;
struct stconn *cs = appctx_cs(appctx);
struct stream *s = __sc_strm(cs);
- struct connection *remote = sc_conn(cs_opposite(cs));
+ struct connection *remote = sc_conn(sc_opposite(cs));
struct msghdr msghdr;
struct iovec iov;
struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
sockaddr_free(&s->scb->dst);
- cs_set_state(s->scb, SC_ST_INI);
+ sc_set_state(s->scb, SC_ST_INI);
s->scb->flags &= SC_FL_ISBACK | SC_FL_DONT_WAKE; /* we're in the context of process_stream */
s->req.flags &= ~(CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CONNECT|CF_WRITE_ERROR|CF_STREAMER|CF_STREAMER_FAST|CF_NEVER_WAIT|CF_WROTE_DATA);
s->res.flags &= ~(CF_SHUTR|CF_SHUTR_NOW|CF_READ_ATTACHED|CF_READ_ERROR|CF_READ_NOEXP|CF_STREAMER|CF_STREAMER_FAST|CF_WRITE_PARTIAL|CF_NEVER_WAIT|CF_WROTE_DATA|CF_READ_NULL);
ic->flags |= CF_SHUTR;
ic->rex = TICK_ETERNITY;
- if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
+ if (!sc_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return;
if (sc_oc(cs)->flags & CF_SHUTW) {
ic->flags |= CF_SHUTR;
ic->rex = TICK_ETERNITY;
- if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
+ if (!sc_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return;
if (sc_oc(cs)->flags & CF_SHUTW) {
BUG_ON(!sc_conn(cs));
/* (re)start reading */
- if (cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
+ if (sc_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
tasklet_wakeup(cs->wait_event.tasklet);
}
BUG_ON(!sc_conn(cs));
- if (unlikely(!cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST) ||
+ if (unlikely(!sc_state_in(cs->state, SC_SB_RDY|SC_SB_EST) ||
(oc->flags & CF_SHUTW)))
return;
if (!(cs->wait_event.events & SUB_RETRY_SEND) && !channel_is_empty(sc_oc(cs)))
sc_conn_send(cs);
- if (sc_ep_test(cs, SE_FL_ERROR | SE_FL_ERR_PENDING) || cs_is_conn_error(cs)) {
+ if (sc_ep_test(cs, SE_FL_ERROR | SE_FL_ERR_PENDING) || sc_is_conn_error(cs)) {
/* Write error on the file descriptor */
if (cs->state >= SC_ST_CON)
sc_ep_set(cs, SE_FL_ERROR);
*/
if (((oc->flags & (CF_SHUTW|CF_AUTO_CLOSE|CF_SHUTW_NOW)) ==
(CF_AUTO_CLOSE|CF_SHUTW_NOW)) &&
- cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST)) {
+ sc_state_in(cs->state, SC_SB_RDY|SC_SB_EST)) {
sc_shutw(cs);
goto out_wakeup;
}
if (likely((oc->flags & (CF_WRITE_NULL|CF_WRITE_ERROR|CF_SHUTW)) ||
((oc->flags & CF_WAKE_WRITE) &&
((channel_is_empty(oc) && !oc->to_forward) ||
- !cs_state_in(cs->state, SC_SB_EST))))) {
+ !sc_state_in(cs->state, SC_SB_EST))))) {
out_wakeup:
if (!(cs->flags & SC_FL_DONT_WAKE))
task_wakeup(sc_strm_task(cs), TASK_WOKEN_IO);
/* Note: on shutr, we don't call the applet */
- if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
+ if (!sc_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return;
if (sc_oc(cs)->flags & CF_SHUTW) {
{
struct channel *ic = sc_ic(cs);
struct channel *oc = sc_oc(cs);
- struct stconn *cso = cs_opposite(cs);
+ struct stconn *cso = sc_opposite(cs);
struct task *task = sc_strm_task(cs);
/* process consumer side */
/* wake the task up only when needed */
if (/* changes on the production side */
(ic->flags & (CF_READ_NULL|CF_READ_ERROR)) ||
- !cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST) ||
+ !sc_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST) ||
sc_ep_test(cs, SE_FL_ERROR) ||
((ic->flags & CF_READ_PARTIAL) &&
((ic->flags & CF_EOI) || !ic->to_forward || cso->state != SC_ST_EST)) ||
ic->flags |= CF_SHUTR;
ic->rex = TICK_ETERNITY;
- if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
+ if (!sc_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return;
if (oc->flags & CF_SHUTW)
}
/* now we'll need a input buffer for the stream */
- if (!cs_alloc_ibuf(cs, &(__sc_strm(cs)->buffer_wait)))
+ if (!sc_alloc_ibuf(cs, &(__sc_strm(cs)->buffer_wait)))
goto end_recv;
/* For an HTX stream, if the buffer is stuck (no output data with some
*/
int sc_conn_sync_recv(struct stconn *cs)
{
- if (!cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST))
+ if (!sc_state_in(cs->state, SC_SB_RDY|SC_SB_EST))
return 0;
if (!sc_mux_ops(cs))
int ret;
int did_send = 0;
- if (sc_ep_test(cs, SE_FL_ERROR | SE_FL_ERR_PENDING) || cs_is_conn_error(cs)) {
+ if (sc_ep_test(cs, SE_FL_ERROR | SE_FL_ERR_PENDING) || sc_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 SC_ST_TAR. There's still
if (cs->state == SC_ST_CON)
cs->state = SC_ST_RDY;
- sc_have_room(cs_opposite(cs));
+ sc_have_room(sc_opposite(cs));
}
if (sc_ep_test(cs, SE_FL_ERROR | SE_FL_ERR_PENDING)) {
if (channel_is_empty(oc))
return;
- if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
+ if (!sc_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return;
if (!sc_mux_ops(cs))
*/
if (cs->state >= SC_ST_CON) {
- if (cs_is_conn_error(cs))
+ if (sc_is_conn_error(cs))
sc_ep_set(cs, SE_FL_ERROR);
}
task_wakeup(sc_strm_task(cs), TASK_WOKEN_MSG);
}
- if (!cs_state_in(cs->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
+ if (!sc_state_in(cs->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
(conn->flags & CO_FL_WAIT_XPRT) == 0) {
__sc_strm(cs)->conn_exp = TICK_ETERNITY;
oc->flags |= CF_WRITE_NULL;
if (cs && sc_strm(cs)) {
ret = make_proxy_line(trash.area, trash.size,
objt_server(conn->target),
- sc_conn(cs_opposite(cs)),
+ sc_conn(sc_opposite(cs)),
__sc_strm(cs));
}
else {
/* if the connection is not established, inform the stream that we want
* to be notified whenever the connection completes.
*/
- if (cs_opposite(cs)->state < SC_ST_EST) {
+ if (sc_opposite(cs)->state < SC_ST_EST) {
applet_need_more_data(appctx);
se_need_remote_conn(appctx->sedesc);
applet_have_more_data(appctx);
* the message so that we can take our reference there if we have to
* stop before the end (ret=0).
*/
- if (cs_opposite(cs)->state == SC_ST_EST) {
+ if (sc_opposite(cs)->state == SC_ST_EST) {
/* we were already there, adjust the offset to be relative to
* the buffer's head and remove us from the counter.
*/
char *frame, *buf;
int ret;
- if (cs_state_in(cs->state, SC_SB_CER|SC_SB_DIS|SC_SB_CLO)) {
+ if (sc_state_in(cs->state, SC_SB_CER|SC_SB_DIS|SC_SB_CLO)) {
/* closed */
SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
goto exit;
}
- if (!cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST)) {
+ if (!sc_state_in(cs->state, SC_SB_RDY|SC_SB_EST)) {
/* not connected yet */
applet_have_more_data(appctx);
task_wakeup(__sc_strm(cs)->task, TASK_WOKEN_MSG);
int ret;
- if (cs->state == SC_ST_CLO || cs_opposite(cs)->state == SC_ST_CLO) {
+ if (cs->state == SC_ST_CLO || sc_opposite(cs)->state == SC_ST_CLO) {
SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
goto exit;
}
struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
int ret, skip_sending = 0, skip_receiving = 0, active_s = 0, active_r = 0, close_asap = 0;
- if (cs->state == SC_ST_CLO || cs_opposite(cs)->state == SC_ST_CLO) {
+ if (cs->state == SC_ST_CLO || sc_opposite(cs)->state == SC_ST_CLO) {
SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
goto exit;
}
char *frame, *buf;
int ret;
- if (cs->state == SC_ST_CLO || cs_opposite(cs)->state == SC_ST_CLO)
+ if (cs->state == SC_ST_CLO || sc_opposite(cs)->state == SC_ST_CLO)
goto exit;
if (appctx->st1 == SPOE_APPCTX_ERR_TOUT)
char *frame;
int ret;
- if (cs->state == SC_ST_CLO || cs_opposite(cs)->state == SC_ST_CLO) {
+ if (cs->state == SC_ST_CLO || sc_opposite(cs)->state == SC_ST_CLO) {
SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
goto exit;
}
/* if the connection is not established, inform the stream that we want
* to be notified whenever the connection completes.
*/
- if (cs_opposite(cs)->state < SC_ST_EST) {
+ if (sc_opposite(cs)->state < SC_ST_EST) {
applet_need_more_data(appctx);
se_need_remote_conn(appctx->sedesc);
applet_have_more_data(appctx);
* and retrieve data from the server. The connection is initialized
* with the "struct server".
*/
- cs_set_state(s->scb, SC_ST_ASS);
+ sc_set_state(s->scb, SC_ST_ASS);
/* Force destination server. */
s->flags |= SF_DIRECT | SF_ASSIGNED | SF_BE_ASSIGNED;
* the request buffer if its not required.
*/
if (s->req.buf.size == 0) {
- if (!cs_alloc_ibuf(cs, &appctx->buffer_wait))
+ if (!sc_alloc_ibuf(cs, &appctx->buffer_wait))
goto hlua_socket_write_yield_return;
}
appctx = container_of(peer, struct hlua_csk_ctx, xref)->appctx;
cs = appctx_cs(appctx);
- dst = sc_dst(cs_opposite(cs));
+ dst = sc_dst(sc_opposite(cs));
if (!dst) {
xref_unlock(&socket->xref, peer);
lua_pushnil(L);
cs = appctx_cs(appctx);
s = __sc_strm(cs);
- if (!sockaddr_alloc(&cs_opposite(cs)->dst, addr, sizeof(*addr))) {
+ if (!sockaddr_alloc(&sc_opposite(cs)->dst, addr, sizeof(*addr))) {
xref_unlock(&socket->xref, peer);
WILL_LJMP(luaL_error(L, "connect: internal error"));
}
struct fcgi_strm_params *params)
{
struct connection *cli_conn = objt_conn(fstrm->sess->origin);
- const struct sockaddr_storage *src = (sc_check(fcgi_strm_sc(fstrm)) ? conn_src(fconn->conn) : sc_src(cs_opposite(fcgi_strm_sc(fstrm))));
- const struct sockaddr_storage *dst = (sc_check(fcgi_strm_sc(fstrm)) ? conn_dst(fconn->conn) : sc_dst(cs_opposite(fcgi_strm_sc(fstrm))));
+ const struct sockaddr_storage *src = (sc_check(fcgi_strm_sc(fstrm)) ? conn_src(fconn->conn) : sc_src(sc_opposite(fcgi_strm_sc(fstrm))));
+ const struct sockaddr_storage *dst = (sc_check(fcgi_strm_sc(fstrm)) ? conn_dst(fconn->conn) : sc_dst(sc_opposite(fcgi_strm_sc(fstrm))));
struct ist p;
if (!sl)
peer_cs = appctx_cs(peer->appctx);
peer_s = __sc_strm(peer_cs);
- chunk_appendf(&trash, " state=%s", cs_state_str(cs_opposite(peer_cs)->state));
+ chunk_appendf(&trash, " state=%s", sc_state_str(sc_opposite(peer_cs)->state));
conn = objt_conn(strm_orig(peer_s));
if (conn)
/* if the connection is not established, inform the stream that we want
* to be notified whenever the connection completes.
*/
- if (cs_opposite(cs)->state < SC_ST_EST) {
+ if (sc_opposite(cs)->state < SC_ST_EST) {
applet_need_more_data(appctx);
se_need_remote_conn(appctx->sedesc);
applet_have_more_data(appctx);
* the message so that we can take our reference there if we have to
* stop before the end (ret=0).
*/
- if (cs_opposite(cs)->state == SC_ST_EST) {
+ if (sc_opposite(cs)->state == SC_ST_EST) {
/* we were already there, adjust the offset to be relative to
* the buffer's head and remove us from the counter.
*/
/* if the connection is not established, inform the stream that we want
* to be notified whenever the connection completes.
*/
- if (cs_opposite(cs)->state < SC_ST_EST) {
+ if (sc_opposite(cs)->state < SC_ST_EST) {
applet_need_more_data(appctx);
se_need_remote_conn(appctx->sedesc);
applet_have_more_data(appctx);
* the message so that we can take our reference there if we have to
* stop before the end (ret=0).
*/
- if (cs_opposite(cs)->state == SC_ST_EST) {
+ if (sc_opposite(cs)->state == SC_ST_EST) {
/* we were already there, adjust the offset to be relative to
* the buffer's head and remove us from the counter.
*/
{ .mask = STRM_EV_STRM_ANA, .name = "strm_ana", .desc = "stream analyzers" },
{ .mask = STRM_EV_STRM_PROC, .name = "strm_proc", .desc = "stream processing" },
- { .mask = STRM_EV_CS_ST, .name = "cs_state", .desc = "processing connector states" },
+ { .mask = STRM_EV_CS_ST, .name = "sc_state", .desc = "processing connector states" },
{ .mask = STRM_EV_HTTP_ANA, .name = "http_ana", .desc = "HTTP analyzers" },
{ .mask = STRM_EV_HTTP_ERR, .name = "http_err", .desc = "error during HTTP analyzis" },
/* Front and back stream connector state */
chunk_appendf(&trace_buf, " CS=(%s,%s)",
- cs_state_str(s->scf->state), cs_state_str(s->scb->state));
+ sc_state_str(s->scf->state), sc_state_str(s->scb->state));
/* If txn is defined, HTTP req/rep states */
if (txn)
if (!s->scb)
goto out_fail_alloc_scb;
- cs_set_state(s->scf, SC_ST_EST);
+ sc_set_state(s->scf, SC_ST_EST);
s->scf->hcto = sess->fe->timeout.clientfin;
if (likely(sess->fe->options2 & PR_O2_INDEPSTR))
}
else if (s->scb->state == SC_ST_QUE)
s->flags |= SF_FINST_Q;
- else if (cs_state_in(s->scb->state, SC_SB_REQ|SC_SB_TAR|SC_SB_ASS|SC_SB_CON|SC_SB_CER|SC_SB_RDY))
+ else if (sc_state_in(s->scb->state, SC_SB_REQ|SC_SB_TAR|SC_SB_ASS|SC_SB_CON|SC_SB_CER|SC_SB_RDY))
s->flags |= SF_FINST_C;
else if (s->scb->state == SC_ST_EST || s->prev_conn_state == SC_ST_EST)
s->flags |= SF_FINST_D;
s->prev_conn_state = scb->state;
/* let's recompute both sides states */
- if (cs_state_in(scf->state, SC_SB_RDY|SC_SB_EST))
+ if (sc_state_in(scf->state, SC_SB_RDY|SC_SB_EST))
sc_update(scf);
- if (cs_state_in(scb->state, SC_SB_RDY|SC_SB_EST))
+ if (sc_state_in(scb->state, SC_SB_RDY|SC_SB_EST))
sc_update(scb);
/* stream connectors are processed outside of process_stream() and must be
*/
srv = objt_server(s->target);
if (unlikely(sc_ep_test(scf, SE_FL_ERROR))) {
- if (cs_state_in(scf->state, SC_SB_EST|SC_SB_DIS)) {
+ if (sc_state_in(scf->state, SC_SB_EST|SC_SB_DIS)) {
sc_shutr(scf);
sc_shutw(scf);
- cs_report_error(scf);
+ sc_report_error(scf);
if (!(req->analysers) && !(res->analysers)) {
_HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
_HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
}
if (unlikely(sc_ep_test(scb, SE_FL_ERROR))) {
- if (cs_state_in(scb->state, SC_SB_EST|SC_SB_DIS)) {
+ if (sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS)) {
sc_shutr(scb);
sc_shutw(scb);
- cs_report_error(scb);
+ sc_report_error(scb);
_HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
if (srv)
_HA_ATOMIC_INC(&srv->counters.failed_resp);
/* note: maybe we should process connection errors here ? */
}
- if (cs_state_in(scb->state, SC_SB_CON|SC_SB_RDY)) {
+ if (sc_state_in(scb->state, SC_SB_CON|SC_SB_RDY)) {
/* we were trying to establish a connection on the server side,
* maybe it succeeded, maybe it failed, maybe we timed out, ...
*/
s->pending_events & TASK_WOKEN_MSG) {
unsigned int flags = req->flags;
- if (cs_state_in(scf->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) {
+ if (sc_state_in(scf->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) {
int max_loops = global.tune.maxpollevents;
unsigned int ana_list;
unsigned int ana_back;
s->pending_events & TASK_WOKEN_MSG) {
unsigned int flags = res->flags;
- if (cs_state_in(scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) {
+ if (sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) {
int max_loops = global.tune.maxpollevents;
unsigned int ana_list;
unsigned int ana_back;
*/
if (unlikely((!req->analysers || (req->analysers == AN_REQ_FLT_END && !(req->flags & CF_FLT_ANALYZE))) &&
!(req->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
- (cs_state_in(scf->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) &&
+ (sc_state_in(scf->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) &&
(req->to_forward != CHN_INFINITE_FORWARD))) {
/* This buffer is freewheeling, there's no analyser
* attached to it. If any data are left in, we'll permit them to
/* we may have a pending connection request, or a connection waiting
* for completion.
*/
- if (cs_state_in(scb->state, SC_SB_REQ|SC_SB_QUE|SC_SB_TAR|SC_SB_ASS)) {
+ if (sc_state_in(scb->state, SC_SB_REQ|SC_SB_QUE|SC_SB_TAR|SC_SB_ASS)) {
/* prune the request variables and swap to the response variables. */
if (s->vars_reqres.scope != SCOPE_RES) {
if (!LIST_ISEMPTY(&s->vars_reqres.head))
/* Benchmarks have shown that it's optimal to do a full resync now */
if (scf->state == SC_ST_DIS ||
- cs_state_in(scb->state, SC_SB_RDY|SC_SB_DIS) ||
+ sc_state_in(scb->state, SC_SB_RDY|SC_SB_DIS) ||
(sc_ep_test(scf, SE_FL_ERROR) && scf->state != SC_ST_CLO) ||
(sc_ep_test(scb, SE_FL_ERROR) && scb->state != SC_ST_CLO))
goto resync_stconns;
*/
if (unlikely((!res->analysers || (res->analysers == AN_RES_FLT_END && !(res->flags & CF_FLT_ANALYZE))) &&
!(res->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
- cs_state_in(scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
+ sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
(res->to_forward != CHN_INFINITE_FORWARD))) {
/* This buffer is freewheeling, there's no analyser
* attached to it. If any data are left in, we'll permit them to
}
if (scf->state == SC_ST_DIS ||
- cs_state_in(scb->state, SC_SB_RDY|SC_SB_DIS) ||
+ sc_state_in(scb->state, SC_SB_RDY|SC_SB_DIS) ||
(sc_ep_test(scf, SE_FL_ERROR) && scf->state != SC_ST_CLO) ||
(sc_ep_test(scb, SE_FL_ERROR) && scb->state != SC_ST_CLO))
goto resync_stconns;
scf->flags &= ~SC_FL_DONT_WAKE;
scb->flags &= ~SC_FL_DONT_WAKE;
- if (likely((scf->state != SC_ST_CLO) || !cs_state_in(scb->state, SC_SB_INI|SC_SB_CLO) ||
+ if (likely((scf->state != SC_ST_CLO) || !sc_state_in(scb->state, SC_SB_INI|SC_SB_CLO) ||
(req->analysers & AN_REQ_FLT_END) || (res->analysers & AN_RES_FLT_END))) {
if ((sess->fe->options & PR_O_CONTSTATS) && (s->flags & SF_BE_ASSIGNED) && !(s->flags & SF_IGNORE))
stream_process_counters(s);
(s->txn ? h1_msg_state_str(s->txn->req.msg_state): "-"), (s->txn ? s->txn->req.flags : 0),
(s->txn ? h1_msg_state_str(s->txn->rsp.msg_state): "-"), (s->txn ? s->txn->rsp.flags : 0), eol,
pfx, req->flags, req->analysers, res->flags, res->analysers, eol,
- pfx, scf, cs_state_str(scf->state), scf->flags, scb, cs_state_str(scb->state), scb->flags, eol,
+ pfx, scf, sc_state_str(scf->state), scf->flags, scb, sc_state_str(scb->state), scb->flags, eol,
pfx, acf, acf ? acf->st0 : 0, acb, acb ? acb->st0 : 0, eol,
pfx, cof, cof ? cof->flags : 0, conn_get_mux_name(cof), cof?cof->ctx:0, conn_get_xprt_name(cof),
cof ? cof->xprt_ctx : 0, conn_get_ctrl_name(cof), conn_fd(cof), eol,
scf = strm->scf;
chunk_appendf(&trash, " scf=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
- scf, scf->flags, cs_state_str(scf->state),
+ scf, scf->flags, sc_state_str(scf->state),
(sc_ep_test(scf, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(scf, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
scf->sedesc->se, sc_ep_get(scf), scf->wait_event.events);
scb = strm->scb;
chunk_appendf(&trash, " scb=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
- scb, scb->flags, cs_state_str(scb->state),
+ scb, scb->flags, sc_state_str(scb->state),
(sc_ep_test(scb, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(scb, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
scb->sedesc->se, sc_ep_get(scb), scb->wait_event.events);
projects / thirdparty / haproxy.git / commitdiff
