mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-09-22 14:21:25 +02:00
Code Issues Projects Releases Wiki Activity

CLEANUP: stconn: tree-wide rename stconn states CS_ST/SB_* to SC_ST/SB_*

Browse Source 
This also follows the natural naming. There are roughly 238 changes, all
totally trivial. conn_stream-t.h has become completely void of any
"conn_stream" related stuff now (except its name).
This commit is contained in:
Willy Tarreau 2022-05-17 19:47:17 +02:00
parent cb04166525
commit 026e8fb290
16 changed files with 238 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1511,7 +1511,7 @@ static void promex_appctx_handle_io(struct appctx *appctx)
int ret; int ret;
res_htx = htx_from_buf(&res->buf); res_htx = htx_from_buf(&res->buf);
if (unlikely(cs->state == CS_ST_DIS || cs->state == CS_ST_CLO)) if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
goto out; goto out;
/* Check if the input buffer is available. */ /* Check if the input buffer is available. */

2
include/haproxy/channel.h
View File

@ -433,7 +433,7 @@ static inline int channel_is_rewritable(const struct channel *chn)
*/ */
static inline int channel_may_send(const struct channel *chn) static inline int channel_may_send(const struct channel *chn)
{ {
return chn_cons(chn)->state == CS_ST_EST; return chn_cons(chn)->state == SC_ST_EST;
} }
/* HTX version of channel_may_recv(). Returns non-zero if the channel can still /* HTX version of channel_may_recv(). Returns non-zero if the channel can still

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

@ -104,34 +104,34 @@ enum sc_flags {
* do not last beyond process_session(). * do not last beyond process_session().
*/ */
enum cs_state { enum cs_state {
CS_ST_INI = 0, /* CS not sollicitated yet */ SC_ST_INI = 0, /* CS not sollicitated yet */
CS_ST_REQ, /* [transient] connection initiation desired and not started yet */ SC_ST_REQ, /* [transient] connection initiation desired and not started yet */
CS_ST_QUE, /* CS waiting in queue */ SC_ST_QUE, /* CS waiting in queue */
CS_ST_TAR, /* CS in turn-around state after failed connect attempt */ SC_ST_TAR, /* CS in turn-around state after failed connect attempt */
CS_ST_ASS, /* server just assigned to this CS */ SC_ST_ASS, /* server just assigned to this CS */
CS_ST_CON, /* initiated connection request (resource exists) */ SC_ST_CON, /* initiated connection request (resource exists) */
CS_ST_CER, /* [transient] previous connection attempt failed (resource released) */ SC_ST_CER, /* [transient] previous connection attempt failed (resource released) */
CS_ST_RDY, /* [transient] ready proven after I/O success during CS_ST_CON */ SC_ST_RDY, /* [transient] ready proven after I/O success during SC_ST_CON */
CS_ST_EST, /* connection established (resource exists) */ SC_ST_EST, /* connection established (resource exists) */
CS_ST_DIS, /* [transient] disconnected from other side, but cleanup not done yet */ SC_ST_DIS, /* [transient] disconnected from other side, but cleanup not done yet */
CS_ST_CLO, /* CS closed, might not existing anymore. Buffers shut. */ SC_ST_CLO, /* CS closed, might not existing anymore. Buffers shut. */
} __attribute__((packed)); } __attribute__((packed));
/* state bits for use with lists of states */ /* state bits for use with lists of states */
enum cs_state_bit { enum cs_state_bit {
CS_SB_NONE = 0, SC_SB_NONE = 0,
CS_SB_INI = 1U << CS_ST_INI, SC_SB_INI = 1U << SC_ST_INI,
CS_SB_REQ = 1U << CS_ST_REQ, SC_SB_REQ = 1U << SC_ST_REQ,
CS_SB_QUE = 1U << CS_ST_QUE, SC_SB_QUE = 1U << SC_ST_QUE,
CS_SB_TAR = 1U << CS_ST_TAR, SC_SB_TAR = 1U << SC_ST_TAR,
CS_SB_ASS = 1U << CS_ST_ASS, SC_SB_ASS = 1U << SC_ST_ASS,
CS_SB_CON = 1U << CS_ST_CON, SC_SB_CON = 1U << SC_ST_CON,
CS_SB_CER = 1U << CS_ST_CER, SC_SB_CER = 1U << SC_ST_CER,
CS_SB_RDY = 1U << CS_ST_RDY, SC_SB_RDY = 1U << SC_ST_RDY,
CS_SB_EST = 1U << CS_ST_EST, SC_SB_EST = 1U << SC_ST_EST,
CS_SB_DIS = 1U << CS_ST_DIS, SC_SB_DIS = 1U << SC_ST_DIS,
CS_SB_CLO = 1U << CS_ST_CLO, SC_SB_CLO = 1U << SC_ST_CLO,
CS_SB_ALL = CS_SB_INI|CS_SB_REQ|CS_SB_QUE|CS_SB_TAR|CS_SB_ASS|CS_SB_CON|CS_SB_CER|CS_SB_RDY|CS_SB_EST|CS_SB_DIS|CS_SB_CLO, SC_SB_ALL = SC_SB_INI|SC_SB_REQ|SC_SB_QUE|SC_SB_TAR|SC_SB_ASS|SC_SB_CON|SC_SB_CER|SC_SB_RDY|SC_SB_EST|SC_SB_DIS|SC_SB_CLO,
}; };
struct stconn; struct stconn;

40
include/haproxy/cs_utils.h
View File

@ -85,7 +85,7 @@ static inline struct stconn *cs_opposite(struct stconn *cs)
} }
/* to be called only when in CS_ST_DIS with SC_FL_ERR */ /* 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 cs_report_error(struct stconn *cs)
{ {
if (!__cs_strm(cs)->conn_err_type) if (!__cs_strm(cs)->conn_err_type)
@ -103,17 +103,17 @@ static inline void cs_set_state(struct stconn *cs, int state)
cs->state = __cs_strm(cs)->prev_conn_state = state; cs->state = __cs_strm(cs)->prev_conn_state = state;
} }
/* returns a bit for a stream connector state, to match against CS_SB_* */ /* 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 cs_state_bit cs_state_bit(enum cs_state state)
{ {
BUG_ON(state > CS_ST_CLO); BUG_ON(state > SC_ST_CLO);
return 1U << state; return 1U << state;
} }
/* returns true if <state> matches one of the CS_SB_* bits in <mask> */ /* 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 cs_state_in(enum cs_state state, enum cs_state_bit mask)
{ {
BUG_ON(mask & ~CS_SB_ALL); BUG_ON(mask & ~SC_SB_ALL);
return !!(cs_state_bit(state) & mask); return !!(cs_state_bit(state) & mask);
} }
@ -130,7 +130,7 @@ static inline int cs_conn_ready(struct stconn *cs)
/* The stream connector is only responsible for the connection during the early /* The stream connector is only responsible for the connection during the early
* states, before plugging a mux. Thus it should only care about CO_FL_ERROR * states, before plugging a mux. Thus it should only care about CO_FL_ERROR
* before CS_ST_EST, and after that it must absolutely ignore it since the mux * before SC_ST_EST, and after that it must absolutely ignore it since the mux
* may hold pending data. This function returns true if such an error was * may hold pending data. This function returns true if such an error was
* reported. Both the CS and the CONN must be valid. * reported. Both the CS and the CONN must be valid.
*/ */
@ -138,7 +138,7 @@ static inline int cs_is_conn_error(const struct stconn *cs)
{ {
struct connection *conn; struct connection *conn;
if (cs->state >= CS_ST_EST) if (cs->state >= SC_ST_EST)
return 0; return 0;
conn = __cs_conn(cs); conn = __cs_conn(cs);
@ -292,13 +292,13 @@ static inline void cs_shutw(struct stconn *cs)
*/ */
static inline void cs_chk_rcv(struct stconn *cs) static inline void cs_chk_rcv(struct stconn *cs)
{ {
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)) if (sc_ep_test(cs, SE_FL_RXBLK_CONN) && cs_state_in(cs_opposite(cs)->state, SC_SB_RDY|SC_SB_EST|SC_SB_DIS|SC_SB_CLO))
cs_rx_conn_rdy(cs); cs_rx_conn_rdy(cs);
if (cs_rx_blocked(cs) || !cs_rx_endp_ready(cs)) if (cs_rx_blocked(cs) || !cs_rx_endp_ready(cs))
return; return;
if (!cs_state_in(cs->state, CS_SB_RDY|CS_SB_EST)) if (!cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST))
return; return;
sc_ep_set(cs, SE_FL_RX_WAIT_EP); sc_ep_set(cs, SE_FL_RX_WAIT_EP);
@ -322,17 +322,17 @@ static inline void cs_update(struct stconn *cs)
static inline const char *cs_state_str(int state) static inline const char *cs_state_str(int state)
{ {
switch (state) { switch (state) {
case CS_ST_INI: return "INI"; case SC_ST_INI: return "INI";
case CS_ST_REQ: return "REQ"; case SC_ST_REQ: return "REQ";
case CS_ST_QUE: return "QUE"; case SC_ST_QUE: return "QUE";
case CS_ST_TAR: return "TAR"; case SC_ST_TAR: return "TAR";
case CS_ST_ASS: return "ASS"; case SC_ST_ASS: return "ASS";
case CS_ST_CON: return "CON"; case SC_ST_CON: return "CON";
case CS_ST_CER: return "CER"; case SC_ST_CER: return "CER";
case CS_ST_RDY: return "RDY"; case SC_ST_RDY: return "RDY";
case CS_ST_EST: return "EST"; case SC_ST_EST: return "EST";
case CS_ST_DIS: return "DIS"; case SC_ST_DIS: return "DIS";
case CS_ST_CLO: return "CLO"; case SC_ST_CLO: return "CLO";
default: return "???"; default: return "???";
} }
} }

4
include/haproxy/stream.h
View File

@ -341,12 +341,12 @@ static inline void stream_choose_redispatch(struct stream *s)
sockaddr_free(&s->scb->dst); sockaddr_free(&s->scb->dst);
s->flags &= ~(SF_DIRECT | SF_ASSIGNED); s->flags &= ~(SF_DIRECT | SF_ASSIGNED);
s->scb->state = CS_ST_REQ; s->scb->state = SC_ST_REQ;
} else { } else {
if (objt_server(s->target)) if (objt_server(s->target))
_HA_ATOMIC_INC(&__objt_server(s->target)->counters.retries); _HA_ATOMIC_INC(&__objt_server(s->target)->counters.retries);
_HA_ATOMIC_INC(&s->be->be_counters.retries); _HA_ATOMIC_INC(&s->be->be_counters.retries);
s->scb->state = CS_ST_ASS; s->scb->state = SC_ST_ASS;
} }
} }

110
src/backend.c
View File

@ -1294,7 +1294,7 @@ static int do_connect_server(struct stream *s, struct connection *conn)
return ret; return ret;
/* we're in the process of establishing a connection */ /* we're in the process of establishing a connection */
s->scb->state = CS_ST_CON; s->scb->state = SC_ST_CON;
} }
else { else {
/* try to reuse the existing connection, it will be /* try to reuse the existing connection, it will be
@ -1302,9 +1302,9 @@ static int do_connect_server(struct stream *s, struct connection *conn)
*/ */
/* Is the connection really ready ? */ /* Is the connection really ready ? */
if (conn->mux->ctl(conn, MUX_STATUS, NULL) & MUX_STATUS_READY) if (conn->mux->ctl(conn, MUX_STATUS, NULL) & MUX_STATUS_READY)
s->scb->state = CS_ST_RDY; s->scb->state = SC_ST_RDY;
else else
s->scb->state = CS_ST_CON; s->scb->state = SC_ST_CON;
} }
/* needs src ip/port for logging */ /* needs src ip/port for logging */
@ -1821,7 +1821,7 @@ skip_reuse:
} }
/* Now handle synchronously connected sockets. We know the stream connector /* Now handle synchronously connected sockets. We know the stream connector
* is at least in state CS_ST_CON. These ones typically are UNIX * is at least in state SC_ST_CON. These ones typically are UNIX
* sockets, socket pairs, andoccasionally TCP connections on the * sockets, socket pairs, andoccasionally TCP connections on the
* loopback on a heavily loaded system. * loopback on a heavily loaded system.
*/ */
@ -1836,12 +1836,12 @@ skip_reuse:
if (!(srv_conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS))) if (!(srv_conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS)))
sc_ep_clr(s->scb, SE_FL_WAIT_FOR_HS); sc_ep_clr(s->scb, SE_FL_WAIT_FOR_HS);
if (!cs_state_in(s->scb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO) && if (!cs_state_in(s->scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
(srv_conn->flags & CO_FL_WAIT_XPRT) == 0) { (srv_conn->flags & CO_FL_WAIT_XPRT) == 0) {
s->conn_exp = TICK_ETERNITY; s->conn_exp = TICK_ETERNITY;
cs_oc(s->scb)->flags |= CF_WRITE_NULL; cs_oc(s->scb)->flags |= CF_WRITE_NULL;
if (s->scb->state == CS_ST_CON) if (s->scb->state == SC_ST_CON)
s->scb->state = CS_ST_RDY; s->scb->state = SC_ST_RDY;
} }
/* Report EOI on the channel if it was reached from the mux point of /* Report EOI on the channel if it was reached from the mux point of
@ -1924,7 +1924,7 @@ int srv_redispatch_connect(struct stream *s)
case SRV_STATUS_QUEUED: case SRV_STATUS_QUEUED:
s->conn_exp = tick_add_ifset(now_ms, s->be->timeout.queue); s->conn_exp = tick_add_ifset(now_ms, s->be->timeout.queue);
s->scb->state = CS_ST_QUE; s->scb->state = SC_ST_QUE;
/* do nothing else and do not wake any other stream up */ /* do nothing else and do not wake any other stream up */
return 1; return 1;
@ -1961,10 +1961,10 @@ static int back_may_abort_req(struct channel *req, struct stream *s)
(channel_is_empty(req) || (s->be->options & PR_O_ABRT_CLOSE)))); (channel_is_empty(req) || (s->be->options & PR_O_ABRT_CLOSE))));
} }
/* Update back stream connector status for input states CS_ST_ASS, CS_ST_QUE, /* Update back stream connector status for input states SC_ST_ASS, SC_ST_QUE,
* CS_ST_TAR. Other input states are simply ignored. * SC_ST_TAR. Other input states are simply ignored.
* Possible output states are CS_ST_CLO, CS_ST_TAR, CS_ST_ASS, CS_ST_REQ, CS_ST_CON * Possible output states are SC_ST_CLO, SC_ST_TAR, SC_ST_ASS, SC_ST_REQ, SC_ST_CON
* and CS_ST_EST. Flags must have previously been updated for timeouts and other * and SC_ST_EST. Flags must have previously been updated for timeouts and other
* conditions. * conditions.
*/ */
void back_try_conn_req(struct stream *s) void back_try_conn_req(struct stream *s)
@ -1975,7 +1975,7 @@ void back_try_conn_req(struct stream *s)
DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
if (cs->state == CS_ST_ASS) { if (cs->state == SC_ST_ASS) {
/* Server assigned to connection request, we have to try to connect now */ /* Server assigned to connection request, we have to try to connect now */
int conn_err; int conn_err;
@ -1992,7 +1992,7 @@ void back_try_conn_req(struct stream *s)
srv = objt_server(s->target); srv = objt_server(s->target);
if (conn_err == SF_ERR_NONE) { if (conn_err == SF_ERR_NONE) {
/* state = CS_ST_CON or CS_ST_EST now */ /* state = SC_ST_CON or SC_ST_EST now */
if (srv) if (srv)
srv_inc_sess_ctr(srv); srv_inc_sess_ctr(srv);
if (srv) if (srv)
@ -2033,7 +2033,7 @@ void back_try_conn_req(struct stream *s)
pendconn_cond_unlink(s->pend_pos); pendconn_cond_unlink(s->pend_pos);
/* no stream was ever accounted for this server */ /* no stream was ever accounted for this server */
cs->state = CS_ST_CLO; cs->state = SC_ST_CLO;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, cs); s->srv_error(s, cs);
DBG_TRACE_STATE("internal error during connection", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_STATE("internal error during connection", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
@ -2044,14 +2044,14 @@ void back_try_conn_req(struct stream *s)
* turn-around now, as the problem is likely a source port * turn-around now, as the problem is likely a source port
* allocation problem, so we want to retry now. * allocation problem, so we want to retry now.
*/ */
cs->state = CS_ST_CER; cs->state = SC_ST_CER;
sc_ep_clr(cs, SE_FL_ERROR); sc_ep_clr(cs, SE_FL_ERROR);
back_handle_st_cer(s); back_handle_st_cer(s);
DBG_TRACE_STATE("connection error, retry", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_STATE("connection error, retry", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
/* now cs->state is one of CS_ST_CLO, CS_ST_TAR, CS_ST_ASS, CS_ST_REQ */ /* now cs->state is one of SC_ST_CLO, SC_ST_TAR, SC_ST_ASS, SC_ST_REQ */
} }
else if (cs->state == CS_ST_QUE) { else if (cs->state == SC_ST_QUE) {
/* connection request was queued, check for any update */ /* connection request was queued, check for any update */
if (!pendconn_dequeue(s)) { if (!pendconn_dequeue(s)) {
/* The connection is not in the queue anymore. Either /* The connection is not in the queue anymore. Either
@ -2061,10 +2061,10 @@ void back_try_conn_req(struct stream *s)
*/ */
s->conn_exp = TICK_ETERNITY; s->conn_exp = TICK_ETERNITY;
if (unlikely(!(s->flags & SF_ASSIGNED))) if (unlikely(!(s->flags & SF_ASSIGNED)))
cs->state = CS_ST_REQ; cs->state = SC_ST_REQ;
else { else {
s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now); s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
cs->state = CS_ST_ASS; cs->state = SC_ST_ASS;
} }
DBG_TRACE_STATE("dequeue connection request", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_STATE("dequeue connection request", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
goto end; goto end;
@ -2088,7 +2088,7 @@ void back_try_conn_req(struct stream *s)
req->flags |= CF_WRITE_TIMEOUT; req->flags |= CF_WRITE_TIMEOUT;
if (!s->conn_err_type) if (!s->conn_err_type)
s->conn_err_type = STRM_ET_QUEUE_TO; s->conn_err_type = STRM_ET_QUEUE_TO;
cs->state = CS_ST_CLO; cs->state = SC_ST_CLO;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, cs); s->srv_error(s, cs);
DBG_TRACE_STATE("connection request still queued", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_STATE("connection request still queued", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
@ -2109,7 +2109,7 @@ void back_try_conn_req(struct stream *s)
/* Nothing changed */ /* Nothing changed */
} }
else if (cs->state == CS_ST_TAR) { else if (cs->state == SC_ST_TAR) {
/* Connection request might be aborted */ /* Connection request might be aborted */
if (back_may_abort_req(req, s)) { if (back_may_abort_req(req, s)) {
s->conn_err_type |= STRM_ET_CONN_ABRT; s->conn_err_type |= STRM_ET_CONN_ABRT;
@ -2128,9 +2128,9 @@ void back_try_conn_req(struct stream *s)
* FIXME: Should we force a redispatch attempt when the server is down ? * FIXME: Should we force a redispatch attempt when the server is down ?
*/ */
if (s->flags & SF_ASSIGNED) if (s->flags & SF_ASSIGNED)
cs->state = CS_ST_ASS; cs->state = SC_ST_ASS;
else else
cs->state = CS_ST_REQ; cs->state = SC_ST_REQ;
DBG_TRACE_STATE("retry connection now", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_STATE("retry connection now", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
} }
@ -2145,7 +2145,7 @@ abort_connection:
s->flags &= ~SF_CONN_EXP; s->flags &= ~SF_CONN_EXP;
cs_shutr(cs); cs_shutr(cs);
cs_shutw(cs); cs_shutw(cs);
cs->state = CS_ST_CLO; cs->state = SC_ST_CLO;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, cs); s->srv_error(s, cs);
DBG_TRACE_DEVEL("leaving on error", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_DEVEL("leaving on error", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
@ -2153,16 +2153,16 @@ abort_connection:
} }
/* This function initiates a server connection request on a stream connector /* This function initiates a server connection request on a stream connector
* already in CS_ST_REQ state. Upon success, the state goes to CS_ST_ASS for * already in SC_ST_REQ state. Upon success, the state goes to SC_ST_ASS for
* a real connection to a server, indicating that a server has been assigned, * a real connection to a server, indicating that a server has been assigned,
* or CS_ST_RDY for a successful connection to an applet. It may also return * or SC_ST_RDY for a successful connection to an applet. It may also return
* CS_ST_QUE, or CS_ST_CLO upon error. * SC_ST_QUE, or SC_ST_CLO upon error.
*/ */
void back_handle_st_req(struct stream *s) void back_handle_st_req(struct stream *s)
{ {
struct stconn *cs = s->scb; struct stconn *cs = s->scb;
if (cs->state != CS_ST_REQ) if (cs->state != SC_ST_REQ)
return; return;
DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
@ -2170,9 +2170,9 @@ void back_handle_st_req(struct stream *s)
if (unlikely(obj_type(s->target) == OBJ_TYPE_APPLET)) { if (unlikely(obj_type(s->target) == OBJ_TYPE_APPLET)) {
struct appctx *appctx; struct appctx *appctx;
/* The target is an applet but the CS is in CS_ST_REQ. Thus it /* The target is an applet but the CS is in SC_ST_REQ. Thus it
* means no appctx are attached to the CS. Otherwise, it will be * means no appctx are attached to the CS. Otherwise, it will be
* in CS_ST_RDY state. So, try to create the appctx now. * in SC_ST_RDY state. So, try to create the appctx now.
*/ */
BUG_ON(cs_appctx(cs)); BUG_ON(cs_appctx(cs));
appctx = cs_applet_create(cs, objt_applet(s->target)); appctx = cs_applet_create(cs, objt_applet(s->target));
@ -2187,7 +2187,7 @@ void back_handle_st_req(struct stream *s)
cs_shutw(cs); cs_shutw(cs);
s->req.flags |= CF_WRITE_ERROR; s->req.flags |= CF_WRITE_ERROR;
s->conn_err_type = STRM_ET_CONN_RES; s->conn_err_type = STRM_ET_CONN_RES;
cs->state = CS_ST_CLO; cs->state = SC_ST_CLO;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, cs); s->srv_error(s, cs);
DBG_TRACE_STATE("failed to register applet", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_STATE("failed to register applet", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
@ -2203,7 +2203,7 @@ void back_handle_st_req(struct stream *s)
/* We did not get a server. Either we queued the /* We did not get a server. Either we queued the
* connection request, or we encountered an error. * connection request, or we encountered an error.
*/ */
if (cs->state == CS_ST_QUE) { if (cs->state == SC_ST_QUE) {
DBG_TRACE_STATE("connection request queued", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_STATE("connection request queued", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
goto end; goto end;
} }
@ -2214,7 +2214,7 @@ void back_handle_st_req(struct stream *s)
s->req.flags |= CF_WRITE_ERROR; s->req.flags |= CF_WRITE_ERROR;
if (!s->conn_err_type) if (!s->conn_err_type)
s->conn_err_type = STRM_ET_CONN_OTHER; s->conn_err_type = STRM_ET_CONN_OTHER;
cs->state = CS_ST_CLO; cs->state = SC_ST_CLO;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, cs); s->srv_error(s, cs);
DBG_TRACE_STATE("connection request failed", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_STATE("connection request failed", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
@ -2223,7 +2223,7 @@ void back_handle_st_req(struct stream *s)
/* The server is assigned */ /* The server is assigned */
s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now); s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
cs->state = CS_ST_ASS; cs->state = SC_ST_ASS;
be_set_sess_last(s->be); be_set_sess_last(s->be);
DBG_TRACE_STATE("connection request assigned to a server", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_STATE("connection request assigned to a server", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
@ -2231,10 +2231,10 @@ void back_handle_st_req(struct stream *s)
DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
} }
/* This function is called with (cs->state == CS_ST_CON) meaning that a /* This function is called with (cs->state == SC_ST_CON) meaning that a
* connection was attempted and that the file descriptor is already allocated. * connection was attempted and that the file descriptor is already allocated.
* We must check for timeout, error and abort. Possible output states are * We must check for timeout, error and abort. Possible output states are
* CS_ST_CER (error), CS_ST_DIS (abort), and CS_ST_CON (no change). This only * SC_ST_CER (error), SC_ST_DIS (abort), and SC_ST_CON (no change). This only
* works with connection-based streams. We know that there were no I/O event * works with connection-based streams. We know that there were no I/O event
* when reaching this function. Timeouts and errors are *not* cleared. * when reaching this function. Timeouts and errors are *not* cleared.
*/ */
@ -2255,7 +2255,7 @@ void back_handle_st_con(struct stream *s)
s->conn_err_type |= STRM_ET_CONN_ABRT; s->conn_err_type |= STRM_ET_CONN_ABRT;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, cs); s->srv_error(s, cs);
/* Note: state = CS_ST_DIS now */ /* Note: state = SC_ST_DIS now */
DBG_TRACE_STATE("client abort during connection attempt", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_STATE("client abort during connection attempt", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
goto end; goto end;
} }
@ -2270,7 +2270,7 @@ void back_handle_st_con(struct stream *s)
s->conn_err_type = STRM_ET_CONN_TO; s->conn_err_type = STRM_ET_CONN_TO;
} }
cs->state = CS_ST_CER; cs->state = SC_ST_CER;
DBG_TRACE_STATE("connection failed, retry", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_STATE("connection failed, retry", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
} }
@ -2278,13 +2278,13 @@ void back_handle_st_con(struct stream *s)
DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
} }
/* This function is called with (cs->state == CS_ST_CER) meaning that a /* This function is called with (cs->state == SC_ST_CER) meaning that a
* previous connection attempt has failed and that the file descriptor * previous connection attempt has failed and that the file descriptor
* has already been released. Possible causes include asynchronous error * has already been released. Possible causes include asynchronous error
* notification and time out. Possible output states are CS_ST_CLO when * notification and time out. Possible output states are SC_ST_CLO when
* retries are exhausted, CS_ST_TAR when a delay is wanted before a new * retries are exhausted, SC_ST_TAR when a delay is wanted before a new
* connection attempt, CS_ST_ASS when it's wise to retry on the same server, * connection attempt, SC_ST_ASS when it's wise to retry on the same server,
* and CS_ST_REQ when an immediate redispatch is wanted. The buffers are * and SC_ST_REQ when an immediate redispatch is wanted. The buffers are
* marked as in error state. Timeouts and errors are cleared before retrying. * marked as in error state. Timeouts and errors are cleared before retrying.
*/ */
void back_handle_st_cer(struct stream *s) void back_handle_st_cer(struct stream *s)
@ -2351,7 +2351,7 @@ void back_handle_st_cer(struct stream *s)
s->req.flags |= CF_WRITE_ERROR; s->req.flags |= CF_WRITE_ERROR;
s->res.flags |= CF_READ_ERROR; s->res.flags |= CF_READ_ERROR;
cs->state = CS_ST_CLO; cs->state = SC_ST_CLO;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, cs); s->srv_error(s, cs);
@ -2385,7 +2385,7 @@ void back_handle_st_cer(struct stream *s)
s->req.flags |= CF_WRITE_ERROR; s->req.flags |= CF_WRITE_ERROR;
s->res.flags |= CF_READ_ERROR; s->res.flags |= CF_READ_ERROR;
cs->state = CS_ST_CLO; cs->state = SC_ST_CLO;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, cs); s->srv_error(s, cs);
@ -2415,10 +2415,10 @@ void back_handle_st_cer(struct stream *s)
s->conn_err_type = STRM_ET_CONN_ERR; s->conn_err_type = STRM_ET_CONN_ERR;
/* only wait when we're retrying on the same server */ /* only wait when we're retrying on the same server */
if ((cs->state == CS_ST_ASS || if ((cs->state == SC_ST_ASS ||
(s->be->lbprm.algo & BE_LB_KIND) != BE_LB_KIND_RR || (s->be->lbprm.algo & BE_LB_KIND) != BE_LB_KIND_RR ||
(s->be->srv_act <= 1)) && !reused) { (s->be->srv_act <= 1)) && !reused) {
cs->state = CS_ST_TAR; cs->state = SC_ST_TAR;
s->conn_exp = tick_add(now_ms, MS_TO_TICKS(delay)); s->conn_exp = tick_add(now_ms, MS_TO_TICKS(delay));
} }
DBG_TRACE_STATE("retry a new connection", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_STATE("retry a new connection", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
@ -2428,11 +2428,11 @@ void back_handle_st_cer(struct stream *s)
DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
} }
/* This function is called with (cs->state == CS_ST_RDY) meaning that a /* This function is called with (cs->state == SC_ST_RDY) meaning that a
* connection was attempted, that the file descriptor is already allocated, * connection was attempted, that the file descriptor is already allocated,
* and that it has succeeded. We must still check for errors and aborts. * and that it has succeeded. We must still check for errors and aborts.
* Possible output states are CS_ST_EST (established), CS_ST_CER (error), * Possible output states are SC_ST_EST (established), SC_ST_CER (error),
* and CS_ST_DIS (abort). This only works with connection-based streams. * and SC_ST_DIS (abort). This only works with connection-based streams.
* Timeouts and errors are *not* cleared. * Timeouts and errors are *not* cleared.
*/ */
void back_handle_st_rdy(struct stream *s) void back_handle_st_rdy(struct stream *s)
@ -2445,7 +2445,7 @@ void back_handle_st_rdy(struct stream *s)
if (unlikely(obj_type(s->target) == OBJ_TYPE_APPLET)) { if (unlikely(obj_type(s->target) == OBJ_TYPE_APPLET)) {
/* Here the appctx must exists because the CS was set to /* Here the appctx must exists because the CS was set to
* CS_ST_RDY state when the appctx was created. * SC_ST_RDY state when the appctx was created.
*/ */
BUG_ON(!cs_appctx(s->scb)); BUG_ON(!cs_appctx(s->scb));
@ -2463,7 +2463,7 @@ void back_handle_st_rdy(struct stream *s)
* - an I/O error might have been reported after a successful transfer, * - an I/O error might have been reported after a successful transfer,
* which is not retryable and needs to be logged correctly, and needs * which is not retryable and needs to be logged correctly, and needs
* established as well * established as well
* - CS_ST_CON implies !CF_WROTE_DATA but not conversely as we could * - SC_ST_CON implies !CF_WROTE_DATA but not conversely as we could
* have validated a connection with incoming data (e.g. TCP with a * have validated a connection with incoming data (e.g. TCP with a
* banner protocol), or just a successful connect() probe. * banner protocol), or just a successful connect() probe.
* - the client might have requested a connection abort, this needs to * - the client might have requested a connection abort, this needs to
@ -2492,7 +2492,7 @@ void back_handle_st_rdy(struct stream *s)
if (sc_ep_test(cs, SE_FL_ERROR)) { if (sc_ep_test(cs, SE_FL_ERROR)) {
if (!s->conn_err_type) if (!s->conn_err_type)
s->conn_err_type = STRM_ET_CONN_ERR; s->conn_err_type = STRM_ET_CONN_ERR;
cs->state = CS_ST_CER; cs->state = SC_ST_CER;
DBG_TRACE_STATE("connection failed, retry", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_STATE("connection failed, retry", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
goto end; goto end;
} }
@ -2503,7 +2503,7 @@ void back_handle_st_rdy(struct stream *s)
*/ */
DBG_TRACE_STATE("connection established", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_STATE("connection established", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
s->conn_err_type = STRM_ET_NONE; s->conn_err_type = STRM_ET_NONE;
cs->state = CS_ST_EST; cs->state = SC_ST_EST;
end: end:
DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);

2
src/cache.c
View File

@ -1466,7 +1466,7 @@ static void http_cache_io_handler(struct appctx *appctx)
res_htx = htx_from_buf(&res->buf); res_htx = htx_from_buf(&res->buf);
total = res_htx->data; total = res_htx->data;
if (unlikely(cs->state == CS_ST_DIS || cs->state == CS_ST_CLO)) if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
goto out; goto out;
/* Check if the input buffer is available. */ /* Check if the input buffer is available. */

8
src/cli.c
View File

@ -904,7 +904,7 @@ static void cli_io_handler(struct appctx *appctx)
int reql; int reql;
int len; int len;
if (unlikely(cs->state == CS_ST_DIS || cs->state == CS_ST_CLO)) if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
goto out; goto out;
/* Check if the input buffer is available. */ /* Check if the input buffer is available. */
@ -1170,7 +1170,7 @@ static void cli_io_handler(struct appctx *appctx)
} }
} }
if ((res->flags & CF_SHUTR) && (cs->state == CS_ST_EST)) { if ((res->flags & CF_SHUTR) && (cs->state == SC_ST_EST)) {
DPRINTF(stderr, "%s@%d: cs to buf closed. req=%08x, res=%08x, st=%d\n", DPRINTF(stderr, "%s@%d: cs to buf closed. req=%08x, res=%08x, st=%d\n",
__FUNCTION__, __LINE__, req->flags, res->flags, cs->state); __FUNCTION__, __LINE__, req->flags, res->flags, cs->state);
/* Other side has closed, let's abort if we have no more processing to do /* Other side has closed, let's abort if we have no more processing to do
@ -1181,7 +1181,7 @@ static void cli_io_handler(struct appctx *appctx)
cs_shutw(cs); cs_shutw(cs);
} }
if ((req->flags & CF_SHUTW) && (cs->state == CS_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) { if ((req->flags & CF_SHUTW) && (cs->state == SC_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
DPRINTF(stderr, "%s@%d: buf to cs closed. req=%08x, res=%08x, st=%d\n", DPRINTF(stderr, "%s@%d: buf to cs closed. req=%08x, res=%08x, st=%d\n",
__FUNCTION__, __LINE__, req->flags, res->flags, cs->state); __FUNCTION__, __LINE__, req->flags, res->flags, cs->state);
/* We have no more processing to do, and nothing more to send, and /* We have no more processing to do, and nothing more to send, and
@ -2787,7 +2787,7 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
sockaddr_free(&s->scb->dst); sockaddr_free(&s->scb->dst);
cs_set_state(s->scb, CS_ST_INI); cs_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->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->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); 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);

106
src/conn_stream.c
View File

@ -127,7 +127,7 @@ static struct stconn *cs_new(struct sedesc *sedesc)
cs->obj_type = OBJ_TYPE_CS; cs->obj_type = OBJ_TYPE_CS;
cs->flags = SC_FL_NONE; cs->flags = SC_FL_NONE;
cs->state = CS_ST_INI; cs->state = SC_ST_INI;
cs->hcto = TICK_ETERNITY; cs->hcto = TICK_ETERNITY;
cs->app = NULL; cs->app = NULL;
cs->data_cb = NULL; cs->data_cb = NULL;
@ -493,7 +493,7 @@ struct appctx *cs_applet_create(struct stconn *cs, struct applet *app)
cs_cant_get(cs); cs_cant_get(cs);
appctx_wakeup(appctx); appctx_wakeup(appctx);
cs->state = CS_ST_RDY; cs->state = SC_ST_RDY;
return appctx; return appctx;
} }
@ -514,11 +514,11 @@ static void sc_app_shutr(struct stconn *cs)
ic->flags |= CF_SHUTR; ic->flags |= CF_SHUTR;
ic->rex = TICK_ETERNITY; ic->rex = TICK_ETERNITY;
if (!cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST)) if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return; return;
if (cs_oc(cs)->flags & CF_SHUTW) { if (cs_oc(cs)->flags & CF_SHUTW) {
cs->state = CS_ST_DIS; cs->state = SC_ST_DIS;
__cs_strm(cs)->conn_exp = TICK_ETERNITY; __cs_strm(cs)->conn_exp = TICK_ETERNITY;
} }
else if (cs->flags & SC_FL_NOHALF) { else if (cs->flags & SC_FL_NOHALF) {
@ -556,8 +556,8 @@ static void sc_app_shutw(struct stconn *cs)
} }
switch (cs->state) { switch (cs->state) {
case CS_ST_RDY: case SC_ST_RDY:
case CS_ST_EST: case SC_ST_EST:
/* we have to shut before closing, otherwise some short messages /* we have to shut before closing, otherwise some short messages
* may never leave the system, especially when there are remaining * may never leave the system, especially when there are remaining
* unread data in the socket input buffer, or when nolinger is set. * unread data in the socket input buffer, or when nolinger is set.
@ -569,12 +569,12 @@ static void sc_app_shutw(struct stconn *cs)
return; return;
/* fall through */ /* fall through */
case CS_ST_CON: case SC_ST_CON:
case CS_ST_CER: case SC_ST_CER:
case CS_ST_QUE: case SC_ST_QUE:
case CS_ST_TAR: case SC_ST_TAR:
/* Note that none of these states may happen with applets */ /* Note that none of these states may happen with applets */
cs->state = CS_ST_DIS; cs->state = SC_ST_DIS;
/* fall through */ /* fall through */
default: default:
cs->flags &= ~SC_FL_NOLINGER; cs->flags &= ~SC_FL_NOLINGER;
@ -618,7 +618,7 @@ static void sc_app_chk_snd(struct stconn *cs)
__FUNCTION__, __FUNCTION__,
cs, cs->state, cs_ic(cs)->flags, oc->flags); cs, cs->state, cs_ic(cs)->flags, oc->flags);
if (unlikely(cs->state != CS_ST_EST || (oc->flags & CF_SHUTW))) if (unlikely(cs->state != SC_ST_EST || (oc->flags & CF_SHUTW)))
return; return;
if (!sc_ep_test(cs, SE_FL_WAIT_DATA) || /* not waiting for data */ if (!sc_ep_test(cs, SE_FL_WAIT_DATA) || /* not waiting for data */
@ -658,12 +658,12 @@ static void sc_app_shutr_conn(struct stconn *cs)
ic->flags |= CF_SHUTR; ic->flags |= CF_SHUTR;
ic->rex = TICK_ETERNITY; ic->rex = TICK_ETERNITY;
if (!cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST)) if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return; return;
if (cs_oc(cs)->flags & CF_SHUTW) { if (cs_oc(cs)->flags & CF_SHUTW) {
cs_conn_shut(cs); cs_conn_shut(cs);
cs->state = CS_ST_DIS; cs->state = SC_ST_DIS;
__cs_strm(cs)->conn_exp = TICK_ETERNITY; __cs_strm(cs)->conn_exp = TICK_ETERNITY;
} }
else if (cs->flags & SC_FL_NOHALF) { else if (cs->flags & SC_FL_NOHALF) {
@ -700,8 +700,8 @@ static void sc_app_shutw_conn(struct stconn *cs)
} }
switch (cs->state) { switch (cs->state) {
case CS_ST_RDY: case SC_ST_RDY:
case CS_ST_EST: case SC_ST_EST:
/* we have to shut before closing, otherwise some short messages /* we have to shut before closing, otherwise some short messages
* may never leave the system, especially when there are remaining * may never leave the system, especially when there are remaining
* unread data in the socket input buffer, or when nolinger is set. * unread data in the socket input buffer, or when nolinger is set.
@ -734,16 +734,16 @@ static void sc_app_shutw_conn(struct stconn *cs)
} }
/* fall through */ /* fall through */
case CS_ST_CON: case SC_ST_CON:
/* we may have to close a pending connection, and mark the /* we may have to close a pending connection, and mark the
* response buffer as shutr * response buffer as shutr
*/ */
cs_conn_shut(cs); cs_conn_shut(cs);
/* fall through */ /* fall through */
case CS_ST_CER: case SC_ST_CER:
case CS_ST_QUE: case SC_ST_QUE:
case CS_ST_TAR: case SC_ST_TAR:
cs->state = CS_ST_DIS; cs->state = SC_ST_DIS;
/* fall through */ /* fall through */
default: default:
cs->flags &= ~SC_FL_NOLINGER; cs->flags &= ~SC_FL_NOLINGER;
@ -765,7 +765,7 @@ static void sc_app_chk_rcv_conn(struct stconn *cs)
BUG_ON(!cs_conn(cs)); BUG_ON(!cs_conn(cs));
/* (re)start reading */ /* (re)start reading */
if (cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST)) if (cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
tasklet_wakeup(cs->wait_event.tasklet); tasklet_wakeup(cs->wait_event.tasklet);
} }
@ -781,7 +781,7 @@ static void sc_app_chk_snd_conn(struct stconn *cs)
BUG_ON(!cs_conn(cs)); BUG_ON(!cs_conn(cs));
if (unlikely(!cs_state_in(cs->state, CS_SB_RDY|CS_SB_EST) || if (unlikely(!cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST) ||
(oc->flags & CF_SHUTW))) (oc->flags & CF_SHUTW)))
return; return;
@ -797,7 +797,7 @@ static void sc_app_chk_snd_conn(struct stconn *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) || cs_is_conn_error(cs)) {
/* Write error on the file descriptor */ /* Write error on the file descriptor */
if (cs->state >= CS_ST_CON) if (cs->state >= SC_ST_CON)
sc_ep_set(cs, SE_FL_ERROR); sc_ep_set(cs, SE_FL_ERROR);
goto out_wakeup; goto out_wakeup;
} }
@ -813,7 +813,7 @@ static void sc_app_chk_snd_conn(struct stconn *cs)
*/ */
if (((oc->flags & (CF_SHUTW|CF_AUTO_CLOSE|CF_SHUTW_NOW)) == if (((oc->flags & (CF_SHUTW|CF_AUTO_CLOSE|CF_SHUTW_NOW)) ==
(CF_AUTO_CLOSE|CF_SHUTW_NOW)) && (CF_AUTO_CLOSE|CF_SHUTW_NOW)) &&
cs_state_in(cs->state, CS_SB_RDY|CS_SB_EST)) { cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST)) {
cs_shutw(cs); cs_shutw(cs);
goto out_wakeup; goto out_wakeup;
} }
@ -858,7 +858,7 @@ static void sc_app_chk_snd_conn(struct stconn *cs)
if (likely((oc->flags & (CF_WRITE_NULL|CF_WRITE_ERROR|CF_SHUTW)) || if (likely((oc->flags & (CF_WRITE_NULL|CF_WRITE_ERROR|CF_SHUTW)) ||
((oc->flags & CF_WAKE_WRITE) && ((oc->flags & CF_WAKE_WRITE) &&
((channel_is_empty(oc) && !oc->to_forward) || ((channel_is_empty(oc) && !oc->to_forward) ||
!cs_state_in(cs->state, CS_SB_EST))))) { !cs_state_in(cs->state, SC_SB_EST))))) {
out_wakeup: out_wakeup:
if (!(cs->flags & SC_FL_DONT_WAKE)) if (!(cs->flags & SC_FL_DONT_WAKE))
task_wakeup(cs_strm_task(cs), TASK_WOKEN_IO); task_wakeup(cs_strm_task(cs), TASK_WOKEN_IO);
@ -887,12 +887,12 @@ static void sc_app_shutr_applet(struct stconn *cs)
/* Note: on shutr, we don't call the applet */ /* Note: on shutr, we don't call the applet */
if (!cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST)) if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return; return;
if (cs_oc(cs)->flags & CF_SHUTW) { if (cs_oc(cs)->flags & CF_SHUTW) {
appctx_shut(__cs_appctx(cs)); appctx_shut(__cs_appctx(cs));
cs->state = CS_ST_DIS; cs->state = SC_ST_DIS;
__cs_strm(cs)->conn_exp = TICK_ETERNITY; __cs_strm(cs)->conn_exp = TICK_ETERNITY;
} }
else if (cs->flags & SC_FL_NOHALF) { else if (cs->flags & SC_FL_NOHALF) {
@ -931,8 +931,8 @@ static void sc_app_shutw_applet(struct stconn *cs)
appctx_wakeup(__cs_appctx(cs)); appctx_wakeup(__cs_appctx(cs));
switch (cs->state) { switch (cs->state) {
case CS_ST_RDY: case SC_ST_RDY:
case CS_ST_EST: case SC_ST_EST:
/* we have to shut before closing, otherwise some short messages /* we have to shut before closing, otherwise some short messages
* may never leave the system, especially when there are remaining * may never leave the system, especially when there are remaining
* unread data in the socket input buffer, or when nolinger is set. * unread data in the socket input buffer, or when nolinger is set.
@ -944,13 +944,13 @@ static void sc_app_shutw_applet(struct stconn *cs)
return; return;
/* fall through */ /* fall through */
case CS_ST_CON: case SC_ST_CON:
case CS_ST_CER: case SC_ST_CER:
case CS_ST_QUE: case SC_ST_QUE:
case CS_ST_TAR: case SC_ST_TAR:
/* Note that none of these states may happen with applets */ /* Note that none of these states may happen with applets */
appctx_shut(__cs_appctx(cs)); appctx_shut(__cs_appctx(cs));
cs->state = CS_ST_DIS; cs->state = SC_ST_DIS;
/* fall through */ /* fall through */
default: default:
cs->flags &= ~SC_FL_NOLINGER; cs->flags &= ~SC_FL_NOLINGER;
@ -989,7 +989,7 @@ static void sc_app_chk_snd_applet(struct stconn *cs)
__FUNCTION__, __FUNCTION__,
cs, cs->state, cs_ic(cs)->flags, oc->flags); cs, cs->state, cs_ic(cs)->flags, oc->flags);
if (unlikely(cs->state != CS_ST_EST || (oc->flags & CF_SHUTW))) if (unlikely(cs->state != SC_ST_EST || (oc->flags & CF_SHUTW)))
return; return;
/* we only wake the applet up if it was waiting for some data */ /* we only wake the applet up if it was waiting for some data */
@ -1121,7 +1121,7 @@ static void cs_notify(struct stconn *cs)
struct connection *conn = cs_conn(cs); struct connection *conn = cs_conn(cs);
if (((oc->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW) && if (((oc->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW) &&
(cs->state == CS_ST_EST) && (!conn || !(conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS)))) (cs->state == SC_ST_EST) && (!conn || !(conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS))))
cs_shutw(cs); cs_shutw(cs);
oc->wex = TICK_ETERNITY; oc->wex = TICK_ETERNITY;
} }
@ -1202,10 +1202,10 @@ static void cs_notify(struct stconn *cs)
/* wake the task up only when needed */ /* wake the task up only when needed */
if (/* changes on the production side */ if (/* changes on the production side */
(ic->flags & (CF_READ_NULL|CF_READ_ERROR)) || (ic->flags & (CF_READ_NULL|CF_READ_ERROR)) ||
!cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST) || !cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST) ||
sc_ep_test(cs, SE_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR) ||
((ic->flags & CF_READ_PARTIAL) && ((ic->flags & CF_READ_PARTIAL) &&
((ic->flags & CF_EOI) || !ic->to_forward || cso->state != CS_ST_EST)) || ((ic->flags & CF_EOI) || !ic->to_forward || cso->state != SC_ST_EST)) ||
/* changes on the consumption side */ /* changes on the consumption side */
(oc->flags & (CF_WRITE_NULL|CF_WRITE_ERROR)) || (oc->flags & (CF_WRITE_NULL|CF_WRITE_ERROR)) ||
@ -1213,7 +1213,7 @@ static void cs_notify(struct stconn *cs)
((oc->flags & CF_SHUTW) || ((oc->flags & CF_SHUTW) ||
(((oc->flags & CF_WAKE_WRITE) || (((oc->flags & CF_WAKE_WRITE) ||
!(oc->flags & (CF_AUTO_CLOSE|CF_SHUTW_NOW|CF_SHUTW))) && !(oc->flags & (CF_AUTO_CLOSE|CF_SHUTW_NOW|CF_SHUTW))) &&
(cso->state != CS_ST_EST || (cso->state != SC_ST_EST ||
(channel_is_empty(oc) && !oc->to_forward)))))) { (channel_is_empty(oc) && !oc->to_forward)))))) {
task_wakeup(task, TASK_WOKEN_IO); task_wakeup(task, TASK_WOKEN_IO);
} }
@ -1251,7 +1251,7 @@ static void cs_conn_read0(struct stconn *cs)
ic->flags |= CF_SHUTR; ic->flags |= CF_SHUTR;
ic->rex = TICK_ETERNITY; ic->rex = TICK_ETERNITY;
if (!cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST)) if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return; return;
if (oc->flags & CF_SHUTW) if (oc->flags & CF_SHUTW)
@ -1277,7 +1277,7 @@ static void cs_conn_read0(struct stconn *cs)
cs_done_get(cs); cs_done_get(cs);
cs->state = CS_ST_DIS; cs->state = SC_ST_DIS;
__cs_strm(cs)->conn_exp = TICK_ETERNITY; __cs_strm(cs)->conn_exp = TICK_ETERNITY;
return; return;
} }
@ -1296,7 +1296,7 @@ static int cs_conn_recv(struct stconn *cs)
int flags = 0; int flags = 0;
/* If not established yet, do nothing. */ /* If not established yet, do nothing. */
if (cs->state != CS_ST_EST) if (cs->state != SC_ST_EST)
return 0; return 0;
/* If another call to cs_conn_recv() failed, and we subscribed to /* If another call to cs_conn_recv() failed, and we subscribed to
@ -1620,7 +1620,7 @@ static int cs_conn_recv(struct stconn *cs)
*/ */
int cs_conn_sync_recv(struct stconn *cs) int cs_conn_sync_recv(struct stconn *cs)
{ {
if (!cs_state_in(cs->state, CS_SB_RDY|CS_SB_EST)) if (!cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST))
return 0; return 0;
if (!cs_conn_mux(cs)) if (!cs_conn_mux(cs))
@ -1652,11 +1652,11 @@ static int cs_conn_send(struct stconn *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) || cs_is_conn_error(cs)) {
/* We're probably there because the tasklet was woken up, /* We're probably there because the tasklet was woken up,
* but process_stream() ran before, detected there were an * but process_stream() ran before, detected there were an
* error and put the CS back to CS_ST_TAR. There's still * error and put the CS back to SC_ST_TAR. There's still
* CO_FL_ERROR on the connection but we don't want to add * CO_FL_ERROR on the connection but we don't want to add
* SE_FL_ERROR back, so give up * SE_FL_ERROR back, so give up
*/ */
if (cs->state < CS_ST_CON) if (cs->state < SC_ST_CON)
return 0; return 0;
sc_ep_set(cs, SE_FL_ERROR); sc_ep_set(cs, SE_FL_ERROR);
return 1; return 1;
@ -1765,8 +1765,8 @@ static int cs_conn_send(struct stconn *cs)
end: end:
if (did_send) { if (did_send) {
oc->flags |= CF_WRITE_PARTIAL | CF_WROTE_DATA; oc->flags |= CF_WRITE_PARTIAL | CF_WROTE_DATA;
if (cs->state == CS_ST_CON) if (cs->state == SC_ST_CON)
cs->state = CS_ST_RDY; cs->state = SC_ST_RDY;
cs_rx_room_rdy(cs_opposite(cs)); cs_rx_room_rdy(cs_opposite(cs));
} }
@ -1798,7 +1798,7 @@ void cs_conn_sync_send(struct stconn *cs)
if (channel_is_empty(oc)) if (channel_is_empty(oc))
return; return;
if (!cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST)) if (!cs_state_in(cs->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return; return;
if (!cs_conn_mux(cs)) if (!cs_conn_mux(cs))
@ -1838,7 +1838,7 @@ static int cs_conn_process(struct stconn *cs)
* care of it. * care of it.
*/ */
if (cs->state >= CS_ST_CON) { if (cs->state >= SC_ST_CON) {
if (cs_is_conn_error(cs)) if (cs_is_conn_error(cs))
sc_ep_set(cs, SE_FL_ERROR); sc_ep_set(cs, SE_FL_ERROR);
} }
@ -1854,12 +1854,12 @@ static int cs_conn_process(struct stconn *cs)
task_wakeup(cs_strm_task(cs), TASK_WOKEN_MSG); task_wakeup(cs_strm_task(cs), TASK_WOKEN_MSG);
} }
if (!cs_state_in(cs->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO) && if (!cs_state_in(cs->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
(conn->flags & CO_FL_WAIT_XPRT) == 0) { (conn->flags & CO_FL_WAIT_XPRT) == 0) {
__cs_strm(cs)->conn_exp = TICK_ETERNITY; __cs_strm(cs)->conn_exp = TICK_ETERNITY;
oc->flags |= CF_WRITE_NULL; oc->flags |= CF_WRITE_NULL;
if (cs->state == CS_ST_CON) if (cs->state == SC_ST_CON)
cs->state = CS_ST_RDY; cs->state = SC_ST_RDY;
} }
/* Report EOS on the channel if it was reached from the mux point of /* Report EOS on the channel if it was reached from the mux point of

4
src/dns.c
View File

@ -471,7 +471,7 @@ static void dns_session_io_handler(struct appctx *appctx)
/* if the connection is not established, inform the stream that we want /* if the connection is not established, inform the stream that we want
* to be notified whenever the connection completes. * to be notified whenever the connection completes.
*/ */
if (cs_opposite(cs)->state < CS_ST_EST) { if (cs_opposite(cs)->state < SC_ST_EST) {
cs_cant_get(cs); cs_cant_get(cs);
cs_rx_conn_blk(cs); cs_rx_conn_blk(cs);
cs_rx_endp_more(cs); cs_rx_endp_more(cs);
@ -506,7 +506,7 @@ static void dns_session_io_handler(struct appctx *appctx)
* the message so that we can take our reference there if we have to * the message so that we can take our reference there if we have to
* stop before the end (ret=0). * stop before the end (ret=0).
*/ */
if (cs_opposite(cs)->state == CS_ST_EST) { if (cs_opposite(cs)->state == SC_ST_EST) {
/* we were already there, adjust the offset to be relative to /* we were already there, adjust the offset to be relative to
* the buffer's head and remove us from the counter. * the buffer's head and remove us from the counter.
*/ */

12
src/flt_spoe.c
View File

@ -1390,13 +1390,13 @@ spoe_handle_connect_appctx(struct appctx *appctx)
char *frame, *buf; char *frame, *buf;
int ret; int ret;
if (cs_state_in(cs->state, CS_SB_CER|CS_SB_DIS|CS_SB_CLO)) { if (cs_state_in(cs->state, SC_SB_CER|SC_SB_DIS|SC_SB_CLO)) {
/* closed */ /* closed */
SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO; SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
goto exit; goto exit;
} }
if (!cs_state_in(cs->state, CS_SB_RDY|CS_SB_EST)) { if (!cs_state_in(cs->state, SC_SB_RDY|SC_SB_EST)) {
/* not connected yet */ /* not connected yet */
cs_rx_endp_more(cs); cs_rx_endp_more(cs);
task_wakeup(__cs_strm(cs)->task, TASK_WOKEN_MSG); task_wakeup(__cs_strm(cs)->task, TASK_WOKEN_MSG);
@ -1457,7 +1457,7 @@ spoe_handle_connecting_appctx(struct appctx *appctx)
int ret; int ret;
if (cs->state == CS_ST_CLO || cs_opposite(cs)->state == CS_ST_CLO) { if (cs->state == SC_ST_CLO || cs_opposite(cs)->state == SC_ST_CLO) {
SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO; SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
goto exit; goto exit;
} }
@ -1709,7 +1709,7 @@ spoe_handle_processing_appctx(struct appctx *appctx)
struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent; 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; int ret, skip_sending = 0, skip_receiving = 0, active_s = 0, active_r = 0, close_asap = 0;
if (cs->state == CS_ST_CLO || cs_opposite(cs)->state == CS_ST_CLO) { if (cs->state == SC_ST_CLO || cs_opposite(cs)->state == SC_ST_CLO) {
SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO; SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
goto exit; goto exit;
} }
@ -1832,7 +1832,7 @@ spoe_handle_disconnect_appctx(struct appctx *appctx)
char *frame, *buf; char *frame, *buf;
int ret; int ret;
if (cs->state == CS_ST_CLO || cs_opposite(cs)->state == CS_ST_CLO) if (cs->state == SC_ST_CLO || cs_opposite(cs)->state == SC_ST_CLO)
goto exit; goto exit;
if (appctx->st1 == SPOE_APPCTX_ERR_TOUT) if (appctx->st1 == SPOE_APPCTX_ERR_TOUT)
@ -1884,7 +1884,7 @@ spoe_handle_disconnecting_appctx(struct appctx *appctx)
char *frame; char *frame;
int ret; int ret;
if (cs->state == CS_ST_CLO || cs_opposite(cs)->state == CS_ST_CLO) { if (cs->state == SC_ST_CLO || cs_opposite(cs)->state == SC_ST_CLO) {
SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO; SPOE_APPCTX(appctx)->status_code = SPOE_FRM_ERR_IO;
goto exit; goto exit;
} }

10
src/hlua.c
View File

@ -1955,7 +1955,7 @@ static void hlua_socket_handler(struct appctx *appctx)
/* if the connection is not established, inform the stream that we want /* if the connection is not established, inform the stream that we want
* to be notified whenever the connection completes. * to be notified whenever the connection completes.
*/ */
if (cs_opposite(cs)->state < CS_ST_EST) { if (cs_opposite(cs)->state < SC_ST_EST) {
cs_cant_get(cs); cs_cant_get(cs);
cs_rx_conn_blk(cs); cs_rx_conn_blk(cs);
cs_rx_endp_more(cs); cs_rx_endp_more(cs);
@ -2000,7 +2000,7 @@ static int hlua_socket_init(struct appctx *appctx)
* and retrieve data from the server. The connection is initialized * and retrieve data from the server. The connection is initialized
* with the "struct server". * with the "struct server".
*/ */
cs_set_state(s->scb, CS_ST_ASS); cs_set_state(s->scb, SC_ST_ASS);
/* Force destination server. */ /* Force destination server. */
s->flags |= SF_DIRECT | SF_ASSIGNED | SF_BE_ASSIGNED; s->flags |= SF_DIRECT | SF_ASSIGNED | SF_BE_ASSIGNED;
@ -9329,7 +9329,7 @@ void hlua_applet_tcp_fct(struct appctx *ctx)
} }
/* If the stream is disconnect or closed, ldo nothing. */ /* If the stream is disconnect or closed, ldo nothing. */
if (unlikely(cs->state == CS_ST_DIS || cs->state == CS_ST_CLO)) if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
return; return;
/* Execute the function. */ /* Execute the function. */
@ -9522,7 +9522,7 @@ void hlua_applet_http_fct(struct appctx *ctx)
res_htx = htx_from_buf(&res->buf); res_htx = htx_from_buf(&res->buf);
/* If the stream is disconnect or closed, ldo nothing. */ /* If the stream is disconnect or closed, ldo nothing. */
if (unlikely(cs->state == CS_ST_DIS || cs->state == CS_ST_CLO)) if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
goto out; goto out;
/* Check if the input buffer is available. */ /* Check if the input buffer is available. */
@ -10151,7 +10151,7 @@ static int hlua_cli_io_handler_fct(struct appctx *appctx)
fcn = ctx->fcn; fcn = ctx->fcn;
/* If the stream is disconnect or closed, ldo nothing. */ /* If the stream is disconnect or closed, ldo nothing. */
if (unlikely(cs->state == CS_ST_DIS || cs->state == CS_ST_CLO)) if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
return 1; return 1;
/* Execute the function. */ /* Execute the function. */

2
src/http_ana.c
View File

@ -4317,7 +4317,7 @@ void http_perform_server_redirect(struct stream *s, struct stconn *cs)
cs_shutr(cs); cs_shutr(cs);
cs_shutw(cs); cs_shutw(cs);
s->conn_err_type = STRM_ET_NONE; s->conn_err_type = STRM_ET_NONE;
cs->state = CS_ST_CLO; cs->state = SC_ST_CLO;
if (!(s->flags & SF_ERR_MASK)) if (!(s->flags & SF_ERR_MASK))
s->flags |= SF_ERR_LOCAL; s->flags |= SF_ERR_LOCAL;

8
src/sink.c
View File

@ -332,7 +332,7 @@ static void sink_forward_io_handler(struct appctx *appctx)
/* if the connection is not established, inform the stream that we want /* if the connection is not established, inform the stream that we want
* to be notified whenever the connection completes. * to be notified whenever the connection completes.
*/ */
if (cs_opposite(cs)->state < CS_ST_EST) { if (cs_opposite(cs)->state < SC_ST_EST) {
cs_cant_get(cs); cs_cant_get(cs);
cs_rx_conn_blk(cs); cs_rx_conn_blk(cs);
cs_rx_endp_more(cs); cs_rx_endp_more(cs);
@ -371,7 +371,7 @@ static void sink_forward_io_handler(struct appctx *appctx)
* the message so that we can take our reference there if we have to * the message so that we can take our reference there if we have to
* stop before the end (ret=0). * stop before the end (ret=0).
*/ */
if (cs_opposite(cs)->state == CS_ST_EST) { if (cs_opposite(cs)->state == SC_ST_EST) {
/* we were already there, adjust the offset to be relative to /* we were already there, adjust the offset to be relative to
* the buffer's head and remove us from the counter. * the buffer's head and remove us from the counter.
*/ */
@ -473,7 +473,7 @@ static void sink_forward_oc_io_handler(struct appctx *appctx)
/* if the connection is not established, inform the stream that we want /* if the connection is not established, inform the stream that we want
* to be notified whenever the connection completes. * to be notified whenever the connection completes.
*/ */
if (cs_opposite(cs)->state < CS_ST_EST) { if (cs_opposite(cs)->state < SC_ST_EST) {
cs_cant_get(cs); cs_cant_get(cs);
cs_rx_conn_blk(cs); cs_rx_conn_blk(cs);
cs_rx_endp_more(cs); cs_rx_endp_more(cs);
@ -512,7 +512,7 @@ static void sink_forward_oc_io_handler(struct appctx *appctx)
* the message so that we can take our reference there if we have to * the message so that we can take our reference there if we have to
* stop before the end (ret=0). * stop before the end (ret=0).
*/ */
if (cs_opposite(cs)->state == CS_ST_EST) { if (cs_opposite(cs)->state == SC_ST_EST) {
/* we were already there, adjust the offset to be relative to /* we were already there, adjust the offset to be relative to
* the buffer's head and remove us from the counter. * the buffer's head and remove us from the counter.
*/ */

2
src/stats.c
View File

@ -4294,7 +4294,7 @@ static void http_stats_io_handler(struct appctx *appctx)
res_htx = htx_from_buf(&res->buf); res_htx = htx_from_buf(&res->buf);
if (unlikely(cs->state == CS_ST_DIS || cs->state == CS_ST_CLO)) if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
goto out; goto out;
/* Check if the input buffer is available. */ /* Check if the input buffer is available. */

116
src/stream.c
View File

@ -420,7 +420,7 @@ struct stream *stream_new(struct session *sess, struct stconn *cs, struct buffer
s->conn_retries = 0; s->conn_retries = 0;
s->conn_exp = TICK_ETERNITY; s->conn_exp = TICK_ETERNITY;
s->conn_err_type = STRM_ET_NONE; s->conn_err_type = STRM_ET_NONE;
s->prev_conn_state = CS_ST_INI; s->prev_conn_state = SC_ST_INI;
t->process = process_stream; t->process = process_stream;
t->context = s; t->context = s;
t->expire = TICK_ETERNITY; t->expire = TICK_ETERNITY;
@ -453,7 +453,7 @@ struct stream *stream_new(struct session *sess, struct stconn *cs, struct buffer
if (!s->scb) if (!s->scb)
goto out_fail_alloc_scb; goto out_fail_alloc_scb;
cs_set_state(s->scf, CS_ST_EST); cs_set_state(s->scf, SC_ST_EST);
s->scf->hcto = sess->fe->timeout.clientfin; s->scf->hcto = sess->fe->timeout.clientfin;
if (likely(sess->fe->options2 & PR_O2_INDEPSTR)) if (likely(sess->fe->options2 & PR_O2_INDEPSTR))
@ -860,13 +860,13 @@ int stream_set_timeout(struct stream *s, enum act_timeout_name name, int timeout
} }
/* /*
* This function handles the transition between the CS_ST_CON state and the * This function handles the transition between the SC_ST_CON state and the
* CS_ST_EST state. It must only be called after switching from CS_ST_CON (or * SC_ST_EST state. It must only be called after switching from SC_ST_CON (or
* CS_ST_INI or CS_ST_RDY) to CS_ST_EST, but only when a ->proto is defined. * SC_ST_INI or SC_ST_RDY) to SC_ST_EST, but only when a ->proto is defined.
* Note that it will switch the interface to CS_ST_DIS if we already have * Note that it will switch the interface to SC_ST_DIS if we already have
* the CF_SHUTR flag, it means we were able to forward the request, and * the CF_SHUTR flag, it means we were able to forward the request, and
* receive the response, before process_stream() had the opportunity to * receive the response, before process_stream() had the opportunity to
* make the switch from CS_ST_CON to CS_ST_EST. When that happens, we want * make the switch from SC_ST_CON to SC_ST_EST. When that happens, we want
* to go through back_establish() anyway, to make sure the analysers run. * to go through back_establish() anyway, to make sure the analysers run.
* Timeouts are cleared. Error are reported on the channel so that analysers * Timeouts are cleared. Error are reported on the channel so that analysers
* can handle them. * can handle them.
@ -940,9 +940,9 @@ static void back_establish(struct stream *s)
} }
req->wex = TICK_ETERNITY; req->wex = TICK_ETERNITY;
/* If we managed to get the whole response, and we don't have anything /* If we managed to get the whole response, and we don't have anything
* left to send, or can't, switch to CS_ST_DIS now. */ * left to send, or can't, switch to SC_ST_DIS now. */
if (rep->flags & (CF_SHUTR | CF_SHUTW)) { if (rep->flags & (CF_SHUTR | CF_SHUTW)) {
s->scb->state = CS_ST_DIS; s->scb->state = SC_ST_DIS;
DBG_TRACE_STATE("response channel shutdwn for read/write", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s); DBG_TRACE_STATE("response channel shutdwn for read/write", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
} }
@ -956,7 +956,7 @@ static void back_establish(struct stream *s)
static void sess_set_term_flags(struct stream *s) static void sess_set_term_flags(struct stream *s)
{ {
if (!(s->flags & SF_FINST_MASK)) { if (!(s->flags & SF_FINST_MASK)) {
if (s->scb->state == CS_ST_INI) { if (s->scb->state == SC_ST_INI) {
/* anything before REQ in fact */ /* anything before REQ in fact */
_HA_ATOMIC_INC(&strm_fe(s)->fe_counters.failed_req); _HA_ATOMIC_INC(&strm_fe(s)->fe_counters.failed_req);
if (strm_li(s) && strm_li(s)->counters) if (strm_li(s) && strm_li(s)->counters)
@ -964,11 +964,11 @@ static void sess_set_term_flags(struct stream *s)
s->flags |= SF_FINST_R; s->flags |= SF_FINST_R;
} }
else if (s->scb->state == CS_ST_QUE) else if (s->scb->state == SC_ST_QUE)
s->flags |= SF_FINST_Q; s->flags |= SF_FINST_Q;
else if (cs_state_in(s->scb->state, CS_SB_REQ|CS_SB_TAR|CS_SB_ASS|CS_SB_CON|CS_SB_CER|CS_SB_RDY)) 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))
s->flags |= SF_FINST_C; s->flags |= SF_FINST_C;
else if (s->scb->state == CS_ST_EST || s->prev_conn_state == CS_ST_EST) else if (s->scb->state == SC_ST_EST || s->prev_conn_state == SC_ST_EST)
s->flags |= SF_FINST_D; s->flags |= SF_FINST_D;
else else
s->flags |= SF_FINST_L; s->flags |= SF_FINST_L;
@ -1533,10 +1533,10 @@ static void stream_update_both_cs(struct stream *s)
s->prev_conn_state = scb->state; s->prev_conn_state = scb->state;
/* let's recompute both sides states */ /* let's recompute both sides states */
if (cs_state_in(scf->state, CS_SB_RDY|CS_SB_EST)) if (cs_state_in(scf->state, SC_SB_RDY|SC_SB_EST))
cs_update(scf); cs_update(scf);
if (cs_state_in(scb->state, CS_SB_RDY|CS_SB_EST)) if (cs_state_in(scb->state, SC_SB_RDY|SC_SB_EST))
cs_update(scb); cs_update(scb);
/* stream connectors are processed outside of process_stream() and must be /* stream connectors are processed outside of process_stream() and must be
@ -1755,7 +1755,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
*/ */
srv = objt_server(s->target); srv = objt_server(s->target);
if (unlikely(sc_ep_test(scf, SE_FL_ERROR))) { if (unlikely(sc_ep_test(scf, SE_FL_ERROR))) {
if (cs_state_in(scf->state, CS_SB_EST|CS_SB_DIS)) { if (cs_state_in(scf->state, SC_SB_EST|SC_SB_DIS)) {
cs_shutr(scf); cs_shutr(scf);
cs_shutw(scf); cs_shutw(scf);
cs_report_error(scf); cs_report_error(scf);
@ -1775,7 +1775,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
} }
if (unlikely(sc_ep_test(scb, SE_FL_ERROR))) { if (unlikely(sc_ep_test(scb, SE_FL_ERROR))) {
if (cs_state_in(scb->state, CS_SB_EST|CS_SB_DIS)) { if (cs_state_in(scb->state, SC_SB_EST|SC_SB_DIS)) {
cs_shutr(scb); cs_shutr(scb);
cs_shutw(scb); cs_shutw(scb);
cs_report_error(scb); cs_report_error(scb);
@ -1798,23 +1798,23 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
/* note: maybe we should process connection errors here ? */ /* note: maybe we should process connection errors here ? */
} }
if (cs_state_in(scb->state, CS_SB_CON|CS_SB_RDY)) { if (cs_state_in(scb->state, SC_SB_CON|SC_SB_RDY)) {
/* we were trying to establish a connection on the server side, /* we were trying to establish a connection on the server side,
* maybe it succeeded, maybe it failed, maybe we timed out, ... * maybe it succeeded, maybe it failed, maybe we timed out, ...
*/ */
if (scb->state == CS_ST_RDY) if (scb->state == SC_ST_RDY)
back_handle_st_rdy(s); back_handle_st_rdy(s);
else if (s->scb->state == CS_ST_CON) else if (s->scb->state == SC_ST_CON)
back_handle_st_con(s); back_handle_st_con(s);
if (scb->state == CS_ST_CER) if (scb->state == SC_ST_CER)
back_handle_st_cer(s); back_handle_st_cer(s);
else if (scb->state == CS_ST_EST) else if (scb->state == SC_ST_EST)
back_establish(s); back_establish(s);
/* state is now one of CS_ST_CON (still in progress), CS_ST_EST /* state is now one of SC_ST_CON (still in progress), SC_ST_EST
* (established), CS_ST_DIS (abort), CS_ST_CLO (last error), * (established), SC_ST_DIS (abort), SC_ST_CLO (last error),
* CS_ST_ASS/CS_ST_TAR/CS_ST_REQ for retryable errors. * SC_ST_ASS/SC_ST_TAR/SC_ST_REQ for retryable errors.
*/ */
} }
@ -1827,8 +1827,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
DBG_TRACE_POINT(STRM_EV_STRM_PROC, s); DBG_TRACE_POINT(STRM_EV_STRM_PROC, s);
/* nothing special to be done on client side */ /* nothing special to be done on client side */
if (unlikely(scf->state == CS_ST_DIS)) { if (unlikely(scf->state == SC_ST_DIS)) {
scf->state = CS_ST_CLO; scf->state = SC_ST_CLO;
/* This is needed only when debugging is enabled, to indicate /* This is needed only when debugging is enabled, to indicate
* client-side close. * client-side close.
@ -1847,8 +1847,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
/* When a server-side connection is released, we have to count it and /* When a server-side connection is released, we have to count it and
* check for pending connections on this server. * check for pending connections on this server.
*/ */
if (unlikely(scb->state == CS_ST_DIS)) { if (unlikely(scb->state == SC_ST_DIS)) {
scb->state = CS_ST_CLO; scb->state = SC_ST_CLO;
srv = objt_server(s->target); srv = objt_server(s->target);
if (srv) { if (srv) {
if (s->flags & SF_CURR_SESS) { if (s->flags & SF_CURR_SESS) {
@ -1866,7 +1866,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (unlikely((global.mode & MODE_DEBUG) && if (unlikely((global.mode & MODE_DEBUG) &&
(!(global.mode & MODE_QUIET) || (!(global.mode & MODE_QUIET) ||
(global.mode & MODE_VERBOSE)))) { (global.mode & MODE_VERBOSE)))) {
if (s->prev_conn_state == CS_ST_EST) { if (s->prev_conn_state == SC_ST_EST) {
chunk_printf(&trash, "%08x:%s.srvcls[%04x:%04x]\n", chunk_printf(&trash, "%08x:%s.srvcls[%04x:%04x]\n",
s->uniq_id, s->be->id, s->uniq_id, s->be->id,
(unsigned short)conn_fd(cs_conn(scf)), (unsigned short)conn_fd(cs_conn(scf)),
@ -1891,7 +1891,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
s->pending_events & TASK_WOKEN_MSG) { s->pending_events & TASK_WOKEN_MSG) {
unsigned int flags = req->flags; unsigned int flags = req->flags;
if (cs_state_in(scf->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) { if (cs_state_in(scf->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) {
int max_loops = global.tune.maxpollevents; int max_loops = global.tune.maxpollevents;
unsigned int ana_list; unsigned int ana_list;
unsigned int ana_back; unsigned int ana_back;
@ -1992,7 +1992,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
s->pending_events & TASK_WOKEN_MSG) { s->pending_events & TASK_WOKEN_MSG) {
unsigned int flags = res->flags; unsigned int flags = res->flags;
if (cs_state_in(scb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) { if (cs_state_in(scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) {
int max_loops = global.tune.maxpollevents; int max_loops = global.tune.maxpollevents;
unsigned int ana_list; unsigned int ana_list;
unsigned int ana_back; unsigned int ana_back;
@ -2105,11 +2105,11 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
sess_set_term_flags(s); sess_set_term_flags(s);
/* Abort the request if a client error occurred while /* Abort the request if a client error occurred while
* the backend stream connector is in the CS_ST_INI * the backend stream connector is in the SC_ST_INI
* state. It is switched into the CS_ST_CLO state and * state. It is switched into the SC_ST_CLO state and
* the request channel is erased. */ * the request channel is erased. */
if (scb->state == CS_ST_INI) { if (scb->state == SC_ST_INI) {
s->scb->state = CS_ST_CLO; s->scb->state = SC_ST_CLO;
channel_abort(req); channel_abort(req);
if (IS_HTX_STRM(s)) if (IS_HTX_STRM(s))
channel_htx_erase(req, htxbuf(&req->buf)); channel_htx_erase(req, htxbuf(&req->buf));
@ -2173,7 +2173,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
*/ */
if (unlikely((!req->analysers || (req->analysers == AN_REQ_FLT_END && !(req->flags & CF_FLT_ANALYZE))) && if (unlikely((!req->analysers || (req->analysers == AN_REQ_FLT_END && !(req->flags & CF_FLT_ANALYZE))) &&
!(req->flags & (CF_SHUTW|CF_SHUTR_NOW)) && !(req->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
(cs_state_in(scf->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) && (cs_state_in(scf->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) &&
(req->to_forward != CHN_INFINITE_FORWARD))) { (req->to_forward != CHN_INFINITE_FORWARD))) {
/* This buffer is freewheeling, there's no analyser /* This buffer is freewheeling, there's no analyser
* attached to it. If any data are left in, we'll permit them to * attached to it. If any data are left in, we'll permit them to
@ -2226,14 +2226,14 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
* - there are data scheduled for emission in the buffer * - there are data scheduled for emission in the buffer
* - the CF_AUTO_CONNECT flag is set (active connection) * - the CF_AUTO_CONNECT flag is set (active connection)
*/ */
if (scb->state == CS_ST_INI) { if (scb->state == SC_ST_INI) {
if (!(req->flags & CF_SHUTW)) { if (!(req->flags & CF_SHUTW)) {
if ((req->flags & CF_AUTO_CONNECT) || !channel_is_empty(req)) { if ((req->flags & CF_AUTO_CONNECT) || !channel_is_empty(req)) {
/* If we have an appctx, there is no connect method, so we /* If we have an appctx, there is no connect method, so we
* immediately switch to the connected state, otherwise we * immediately switch to the connected state, otherwise we
* perform a connection request. * perform a connection request.
*/ */
scb->state = CS_ST_REQ; /* new connection requested */ scb->state = SC_ST_REQ; /* new connection requested */
s->conn_retries = 0; s->conn_retries = 0;
if ((s->be->retry_type &~ PR_RE_CONN_FAILED) && if ((s->be->retry_type &~ PR_RE_CONN_FAILED) &&
(s->be->mode == PR_MODE_HTTP) && (s->be->mode == PR_MODE_HTTP) &&
@ -2242,7 +2242,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
} }
} }
else { else {
s->scb->state = CS_ST_CLO; /* shutw+ini = abort */ s->scb->state = SC_ST_CLO; /* shutw+ini = abort */
channel_shutw_now(req); /* fix buffer flags upon abort */ channel_shutw_now(req); /* fix buffer flags upon abort */
channel_shutr_now(res); channel_shutr_now(res);
} }
@ -2252,7 +2252,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
/* we may have a pending connection request, or a connection waiting /* we may have a pending connection request, or a connection waiting
* for completion. * for completion.
*/ */
if (cs_state_in(scb->state, CS_SB_REQ|CS_SB_QUE|CS_SB_TAR|CS_SB_ASS)) { if (cs_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. */ /* prune the request variables and swap to the response variables. */
if (s->vars_reqres.scope != SCOPE_RES) { if (s->vars_reqres.scope != SCOPE_RES) {
if (!LIST_ISEMPTY(&s->vars_reqres.head)) if (!LIST_ISEMPTY(&s->vars_reqres.head))
@ -2264,26 +2264,26 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
/* nb: step 1 might switch from QUE to ASS, but we first want /* nb: step 1 might switch from QUE to ASS, but we first want
* to give a chance to step 2 to perform a redirect if needed. * to give a chance to step 2 to perform a redirect if needed.
*/ */
if (scb->state != CS_ST_REQ) if (scb->state != SC_ST_REQ)
back_try_conn_req(s); back_try_conn_req(s);
if (scb->state == CS_ST_REQ) if (scb->state == SC_ST_REQ)
back_handle_st_req(s); back_handle_st_req(s);
/* get a chance to complete an immediate connection setup */ /* get a chance to complete an immediate connection setup */
if (scb->state == CS_ST_RDY) if (scb->state == SC_ST_RDY)
goto resync_stconns; goto resync_stconns;
/* applets directly go to the ESTABLISHED state. Similarly, /* applets directly go to the ESTABLISHED state. Similarly,
* servers experience the same fate when their connection * servers experience the same fate when their connection
* is reused. * is reused.
*/ */
if (unlikely(scb->state == CS_ST_EST)) if (unlikely(scb->state == SC_ST_EST))
back_establish(s); back_establish(s);
srv = objt_server(s->target); srv = objt_server(s->target);
if (scb->state == CS_ST_ASS && srv && srv->rdr_len && (s->flags & SF_REDIRECTABLE)) if (scb->state == SC_ST_ASS && srv && srv->rdr_len && (s->flags & SF_REDIRECTABLE))
http_perform_server_redirect(s, scb); http_perform_server_redirect(s, scb);
} while (scb->state == CS_ST_ASS); } while (scb->state == SC_ST_ASS);
} }
/* Let's see if we can send the pending request now */ /* Let's see if we can send the pending request now */
@ -2301,7 +2301,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
*/ */
if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) == if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
(CF_AUTO_CLOSE|CF_SHUTR) && (CF_AUTO_CLOSE|CF_SHUTR) &&
(scb->state != CS_ST_CON || (s->be->options & PR_O_ABRT_CLOSE)))) { (scb->state != SC_ST_CON || (s->be->options & PR_O_ABRT_CLOSE)))) {
channel_shutw_now(req); channel_shutw_now(req);
} }
@ -2326,10 +2326,10 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
} }
/* Benchmarks have shown that it's optimal to do a full resync now */ /* Benchmarks have shown that it's optimal to do a full resync now */
if (scf->state == CS_ST_DIS || if (scf->state == SC_ST_DIS ||
cs_state_in(scb->state, CS_SB_RDY|CS_SB_DIS) || cs_state_in(scb->state, SC_SB_RDY|SC_SB_DIS) ||
(sc_ep_test(scf, SE_FL_ERROR) && scf->state != CS_ST_CLO) || (sc_ep_test(scf, SE_FL_ERROR) && scf->state != SC_ST_CLO) ||
(sc_ep_test(scb, SE_FL_ERROR) && scb->state != CS_ST_CLO)) (sc_ep_test(scb, SE_FL_ERROR) && scb->state != SC_ST_CLO))
goto resync_stconns; goto resync_stconns;
/* otherwise we want to check if we need to resync the req buffer or not */ /* otherwise we want to check if we need to resync the req buffer or not */
@ -2345,7 +2345,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
*/ */
if (unlikely((!res->analysers || (res->analysers == AN_RES_FLT_END && !(res->flags & CF_FLT_ANALYZE))) && if (unlikely((!res->analysers || (res->analysers == AN_RES_FLT_END && !(res->flags & CF_FLT_ANALYZE))) &&
!(res->flags & (CF_SHUTW|CF_SHUTR_NOW)) && !(res->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
cs_state_in(scb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO) && cs_state_in(scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
(res->to_forward != CHN_INFINITE_FORWARD))) { (res->to_forward != CHN_INFINITE_FORWARD))) {
/* This buffer is freewheeling, there's no analyser /* This buffer is freewheeling, there's no analyser
* attached to it. If any data are left in, we'll permit them to * attached to it. If any data are left in, we'll permit them to
@ -2450,10 +2450,10 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
cs_shutr(scb); cs_shutr(scb);
} }
if (scf->state == CS_ST_DIS || if (scf->state == SC_ST_DIS ||
cs_state_in(scb->state, CS_SB_RDY|CS_SB_DIS) || cs_state_in(scb->state, SC_SB_RDY|SC_SB_DIS) ||
(sc_ep_test(scf, SE_FL_ERROR) && scf->state != CS_ST_CLO) || (sc_ep_test(scf, SE_FL_ERROR) && scf->state != SC_ST_CLO) ||
(sc_ep_test(scb, SE_FL_ERROR) && scb->state != CS_ST_CLO)) (sc_ep_test(scb, SE_FL_ERROR) && scb->state != SC_ST_CLO))
goto resync_stconns; goto resync_stconns;
if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER) if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER)
@ -2469,7 +2469,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
scf->flags &= ~SC_FL_DONT_WAKE; scf->flags &= ~SC_FL_DONT_WAKE;
scb->flags &= ~SC_FL_DONT_WAKE; scb->flags &= ~SC_FL_DONT_WAKE;
if (likely((scf->state != CS_ST_CLO) || !cs_state_in(scb->state, CS_SB_INI|CS_SB_CLO) || if (likely((scf->state != SC_ST_CLO) || !cs_state_in(scb->state, SC_SB_INI|SC_SB_CLO) ||
(req->analysers & AN_REQ_FLT_END) || (res->analysers & AN_RES_FLT_END))) { (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)) if ((sess->fe->options & PR_O_CONTSTATS) && (s->flags & SF_BE_ASSIGNED) && !(s->flags & SF_IGNORE))
stream_process_counters(s); stream_process_counters(s);