sinjuginas/haproxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CLEANUP: stream: rename "csf" and "csb" to "scf" and "scb"

Browse Source 
These are the stream connectors, let's give them consistent names. The
patch is large (405 locations) but totally trivial.
This commit is contained in:
Willy Tarreau 2022-05-17 19:40:40 +02:00
parent c105492bf5
commit 7cb9e6c6ba
27 changed files with 378 additions and 378 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/haproxy/channel.h
View File

@ -68,18 +68,18 @@ static inline struct stream *chn_strm(const struct channel *chn)
static inline struct stconn *chn_prod(const struct channel *chn) static inline struct stconn *chn_prod(const struct channel *chn)
{ {
if (chn->flags & CF_ISRESP) if (chn->flags & CF_ISRESP)
return LIST_ELEM(chn, struct stream *, res)->csb; return LIST_ELEM(chn, struct stream *, res)->scb;
else else
return LIST_ELEM(chn, struct stream *, req)->csf; return LIST_ELEM(chn, struct stream *, req)->scf;
} }
/* returns a pointer to the stream connector consuming the channel (producer) */ /* returns a pointer to the stream connector consuming the channel (producer) */
static inline struct stconn *chn_cons(const struct channel *chn) static inline struct stconn *chn_cons(const struct channel *chn)
{ {
if (chn->flags & CF_ISRESP) if (chn->flags & CF_ISRESP)
return LIST_ELEM(chn, struct stream *, res)->csf; return LIST_ELEM(chn, struct stream *, res)->scf;
else else
return LIST_ELEM(chn, struct stream *, req)->csb; return LIST_ELEM(chn, struct stream *, req)->scb;
} }
/* c_orig() : returns the pointer to the channel buffer's origin */ /* c_orig() : returns the pointer to the channel buffer's origin */

2
include/haproxy/cs_utils.h
View File

@ -81,7 +81,7 @@ static inline struct stconn *cs_opposite(struct stconn *cs)
{ {
struct stream *strm = __cs_strm(cs); struct stream *strm = __cs_strm(cs);
return ((cs->flags & CS_FL_ISBACK) ? strm->csf : strm->csb); return ((cs->flags & CS_FL_ISBACK) ? strm->scf : strm->scb);
} }

4
include/haproxy/stream-t.h
View File

@ -187,8 +187,8 @@ struct stream {
struct vars vars_txn; /* list of variables for the txn scope. */ struct vars vars_txn; /* list of variables for the txn scope. */
struct vars vars_reqres; /* list of variables for the request and resp scope. */ struct vars vars_reqres; /* list of variables for the request and resp scope. */
struct stconn *csf; /* frontend stream connector */ struct stconn *scf; /* frontend stream connector */
struct stconn *csb; /* backend stream connector */ struct stconn *scb; /* backend stream connector */
struct strm_logs logs; /* logs for this stream */ struct strm_logs logs; /* logs for this stream */

6
include/haproxy/stream.h
View File

@ -339,14 +339,14 @@ static inline void stream_choose_redispatch(struct stream *s)
if (may_dequeue_tasks(objt_server(s->target), s->be)) if (may_dequeue_tasks(objt_server(s->target), s->be))
process_srv_queue(objt_server(s->target)); process_srv_queue(objt_server(s->target));
sockaddr_free(&s->csb->dst); sockaddr_free(&s->scb->dst);
s->flags &= ~(SF_DIRECT | SF_ASSIGNED); s->flags &= ~(SF_DIRECT | SF_ASSIGNED);
s->csb->state = CS_ST_REQ; s->scb->state = CS_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->csb->state = CS_ST_ASS; s->scb->state = CS_ST_ASS;
} }
} }

72
src/backend.c
View File

@ -733,7 +733,7 @@ int assign_server(struct stream *s)
const struct sockaddr_storage *src; const struct sockaddr_storage *src;
case BE_LB_HASH_SRC: case BE_LB_HASH_SRC:
src = cs_src(s->csf); src = cs_src(s->scf);
if (src && src->ss_family == AF_INET) { if (src && src->ss_family == AF_INET) {
srv = get_server_sh(s->be, srv = get_server_sh(s->be,
(void *)&((struct sockaddr_in *)src)->sin_addr, (void *)&((struct sockaddr_in *)src)->sin_addr,
@ -894,7 +894,7 @@ static int alloc_dst_address(struct sockaddr_storage **ss,
* locally on multiple addresses at once. Nothing is done * locally on multiple addresses at once. Nothing is done
* for AF_UNIX addresses. * for AF_UNIX addresses.
*/ */
dst = cs_dst(s->csf); dst = cs_dst(s->scf);
if (dst && dst->ss_family == AF_INET) { if (dst && dst->ss_family == AF_INET) {
((struct sockaddr_in *)*ss)->sin_family = AF_INET; ((struct sockaddr_in *)*ss)->sin_family = AF_INET;
((struct sockaddr_in *)*ss)->sin_addr = ((struct sockaddr_in *)*ss)->sin_addr =
@ -911,7 +911,7 @@ static int alloc_dst_address(struct sockaddr_storage **ss,
if ((srv->flags & SRV_F_MAPPORTS)) { if ((srv->flags & SRV_F_MAPPORTS)) {
int base_port; int base_port;
dst = cs_dst(s->csf); dst = cs_dst(s->scf);
if (dst) { if (dst) {
/* First, retrieve the port from the incoming connection */ /* First, retrieve the port from the incoming connection */
base_port = get_host_port(dst); base_port = get_host_port(dst);
@ -934,7 +934,7 @@ static int alloc_dst_address(struct sockaddr_storage **ss,
return SRV_STATUS_INTERNAL; return SRV_STATUS_INTERNAL;
/* in transparent mode, use the original dest addr if no dispatch specified */ /* in transparent mode, use the original dest addr if no dispatch specified */
dst = cs_dst(s->csf); dst = cs_dst(s->scf);
if (dst && (dst->ss_family == AF_INET || dst->ss_family == AF_INET6)) if (dst && (dst->ss_family == AF_INET || dst->ss_family == AF_INET6))
**ss = *dst; **ss = *dst;
} }
@ -1111,7 +1111,7 @@ static int alloc_bind_address(struct sockaddr_storage **ss,
case CO_SRC_TPROXY_CLI: case CO_SRC_TPROXY_CLI:
case CO_SRC_TPROXY_CIP: case CO_SRC_TPROXY_CIP:
/* FIXME: what can we do if the client connects in IPv6 or unix socket ? */ /* FIXME: what can we do if the client connects in IPv6 or unix socket ? */
addr = cs_src(s->csf); addr = cs_src(s->scf);
if (!addr) if (!addr)
return SRV_STATUS_INTERNAL; return SRV_STATUS_INTERNAL;
@ -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->csb->state = CS_ST_CON; s->scb->state = CS_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->csb->state = CS_ST_RDY; s->scb->state = CS_ST_RDY;
else else
s->csb->state = CS_ST_CON; s->scb->state = CS_ST_CON;
} }
/* needs src ip/port for logging */ /* needs src ip/port for logging */
@ -1316,7 +1316,7 @@ static int do_connect_server(struct stream *s, struct connection *conn)
/* /*
* This function initiates a connection to the server assigned to this stream * This function initiates a connection to the server assigned to this stream
* (s->target, (s->csb)->addr.to). It will assign a server if none * (s->target, (s->scb)->addr.to). It will assign a server if none
* is assigned yet. * is assigned yet.
* It can return one of : * It can return one of :
* - SF_ERR_NONE if everything's OK * - SF_ERR_NONE if everything's OK
@ -1349,7 +1349,7 @@ static int connect_server(struct stream *s)
* it can be NULL for dispatch mode or transparent backend */ * it can be NULL for dispatch mode or transparent backend */
srv = objt_server(s->target); srv = objt_server(s->target);
err = alloc_dst_address(&s->csb->dst, srv, s); err = alloc_dst_address(&s->scb->dst, srv, s);
if (err != SRV_STATUS_OK) if (err != SRV_STATUS_OK)
return SF_ERR_INTERNAL; return SF_ERR_INTERNAL;
@ -1401,7 +1401,7 @@ static int connect_server(struct stream *s)
/* 3. destination address */ /* 3. destination address */
if (srv && (!is_addr(&srv->addr) || srv->flags & SRV_F_MAPPORTS)) if (srv && (!is_addr(&srv->addr) || srv->flags & SRV_F_MAPPORTS))
hash_params.dst_addr = s->csb->dst; hash_params.dst_addr = s->scb->dst;
/* 4. source address */ /* 4. source address */
hash_params.src_addr = bind_addr; hash_params.src_addr = bind_addr;
@ -1574,11 +1574,11 @@ static int connect_server(struct stream *s)
} }
if (avail >= 1) { if (avail >= 1) {
if (srv_conn->mux->attach(srv_conn, s->csb->sedesc, s->sess) == -1) { if (srv_conn->mux->attach(srv_conn, s->scb->sedesc, s->sess) == -1) {
srv_conn = NULL; srv_conn = NULL;
if (cs_reset_endp(s->csb) < 0) if (cs_reset_endp(s->scb) < 0)
return SF_ERR_INTERNAL; return SF_ERR_INTERNAL;
sc_ep_clr(s->csb, ~SE_FL_DETACHED); sc_ep_clr(s->scb, ~SE_FL_DETACHED);
} }
} }
else else
@ -1624,7 +1624,7 @@ skip_reuse:
return SF_ERR_RESOURCE; return SF_ERR_RESOURCE;
/* copy the target address into the connection */ /* copy the target address into the connection */
*srv_conn->dst = *s->csb->dst; *srv_conn->dst = *s->scb->dst;
/* Copy network namespace from client connection */ /* Copy network namespace from client connection */
srv_conn->proxy_netns = cli_conn ? cli_conn->proxy_netns : NULL; srv_conn->proxy_netns = cli_conn ? cli_conn->proxy_netns : NULL;
@ -1651,11 +1651,11 @@ skip_reuse:
return SF_ERR_INTERNAL; /* how did we get there ? */ return SF_ERR_INTERNAL; /* how did we get there ? */
} }
if (cs_attach_mux(s->csb, NULL, srv_conn) < 0) { if (cs_attach_mux(s->scb, NULL, srv_conn) < 0) {
conn_free(srv_conn); conn_free(srv_conn);
return SF_ERR_INTERNAL; /* how did we get there ? */ return SF_ERR_INTERNAL; /* how did we get there ? */
} }
srv_conn->ctx = s->csb; srv_conn->ctx = s->scb;
#if defined(USE_OPENSSL) && defined(TLSEXT_TYPE_application_layer_protocol_negotiation) #if defined(USE_OPENSSL) && defined(TLSEXT_TYPE_application_layer_protocol_negotiation)
if (!srv || if (!srv ||
@ -1722,7 +1722,7 @@ skip_reuse:
/* disable lingering */ /* disable lingering */
if (s->be->options & PR_O_TCP_NOLING) if (s->be->options & PR_O_TCP_NOLING)
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
if (s->flags & SF_SRV_REUSED) { if (s->flags & SF_SRV_REUSED) {
_HA_ATOMIC_INC(&s->be->be_counters.reuse); _HA_ATOMIC_INC(&s->be->be_counters.reuse);
@ -1764,7 +1764,7 @@ skip_reuse:
if (init_mux) { if (init_mux) {
const struct mux_ops *alt_mux = const struct mux_ops *alt_mux =
likely(!(s->flags & SF_WEBSOCKET)) ? NULL : srv_get_ws_proto(srv); likely(!(s->flags & SF_WEBSOCKET)) ? NULL : srv_get_ws_proto(srv);
if (conn_install_mux_be(srv_conn, s->csb, s->sess, alt_mux) < 0) { if (conn_install_mux_be(srv_conn, s->scb, s->sess, alt_mux) < 0) {
conn_full_close(srv_conn); conn_full_close(srv_conn);
return SF_ERR_INTERNAL; return SF_ERR_INTERNAL;
} }
@ -1802,7 +1802,7 @@ skip_reuse:
*/ */
((cli_conn->flags & CO_FL_EARLY_DATA) || ((cli_conn->flags & CO_FL_EARLY_DATA) ||
((s->be->retry_type & PR_RE_EARLY_ERROR) && !s->conn_retries)) && ((s->be->retry_type & PR_RE_EARLY_ERROR) && !s->conn_retries)) &&
!channel_is_empty(cs_oc(s->csb)) && !channel_is_empty(cs_oc(s->scb)) &&
srv_conn->flags & CO_FL_SSL_WAIT_HS) srv_conn->flags & CO_FL_SSL_WAIT_HS)
srv_conn->flags &= ~(CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN); srv_conn->flags &= ~(CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN);
#endif #endif
@ -1826,7 +1826,7 @@ skip_reuse:
* loopback on a heavily loaded system. * loopback on a heavily loaded system.
*/ */
if (srv_conn->flags & CO_FL_ERROR) if (srv_conn->flags & CO_FL_ERROR)
sc_ep_set(s->csb, SE_FL_ERROR); sc_ep_set(s->scb, SE_FL_ERROR);
/* If we had early data, and the handshake ended, then /* If we had early data, and the handshake ended, then
* we can remove the flag, and attempt to wake the task up, * we can remove the flag, and attempt to wake the task up,
@ -1834,14 +1834,14 @@ skip_reuse:
* the handshake. * the handshake.
*/ */
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->csb, SE_FL_WAIT_FOR_HS); sc_ep_clr(s->scb, SE_FL_WAIT_FOR_HS);
if (!cs_state_in(s->csb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO) && if (!cs_state_in(s->scb->state, CS_SB_EST|CS_SB_DIS|CS_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->csb)->flags |= CF_WRITE_NULL; cs_oc(s->scb)->flags |= CF_WRITE_NULL;
if (s->csb->state == CS_ST_CON) if (s->scb->state == CS_ST_CON)
s->csb->state = CS_ST_RDY; s->scb->state = CS_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
@ -1851,8 +1851,8 @@ skip_reuse:
* wake callback. Otherwise si_cs_recv()/si_cs_send() already take * wake callback. Otherwise si_cs_recv()/si_cs_send() already take
* care of it. * care of it.
*/ */
if (sc_ep_test(s->csb, SE_FL_EOI) && !(cs_ic(s->csb)->flags & CF_EOI)) if (sc_ep_test(s->scb, SE_FL_EOI) && !(cs_ic(s->scb)->flags & CF_EOI))
cs_ic(s->csb)->flags |= (CF_EOI|CF_READ_PARTIAL); cs_ic(s->scb)->flags |= (CF_EOI|CF_READ_PARTIAL);
/* catch all sync connect while the mux is not already installed */ /* catch all sync connect while the mux is not already installed */
if (!srv_conn->mux && !(srv_conn->flags & CO_FL_WAIT_XPRT)) { if (!srv_conn->mux && !(srv_conn->flags & CO_FL_WAIT_XPRT)) {
@ -1901,7 +1901,7 @@ int srv_redispatch_connect(struct stream *s)
if (((s->flags & (SF_DIRECT|SF_FORCE_PRST)) == SF_DIRECT) && if (((s->flags & (SF_DIRECT|SF_FORCE_PRST)) == SF_DIRECT) &&
(s->be->options & PR_O_REDISP)) { (s->be->options & PR_O_REDISP)) {
s->flags &= ~(SF_DIRECT | SF_ASSIGNED); s->flags &= ~(SF_DIRECT | SF_ASSIGNED);
sockaddr_free(&s->csb->dst); sockaddr_free(&s->scb->dst);
goto redispatch; goto redispatch;
} }
@ -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->csb->state = CS_ST_QUE; s->scb->state = CS_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;
@ -1970,7 +1970,7 @@ static int back_may_abort_req(struct channel *req, struct stream *s)
void back_try_conn_req(struct stream *s) void back_try_conn_req(struct stream *s)
{ {
struct server *srv = objt_server(s->target); struct server *srv = objt_server(s->target);
struct stconn *cs = s->csb; struct stconn *cs = s->scb;
struct channel *req = &s->req; struct channel *req = &s->req;
DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
@ -2160,7 +2160,7 @@ abort_connection:
*/ */
void back_handle_st_req(struct stream *s) void back_handle_st_req(struct stream *s)
{ {
struct stconn *cs = s->csb; struct stconn *cs = s->scb;
if (cs->state != CS_ST_REQ) if (cs->state != CS_ST_REQ)
return; return;
@ -2240,7 +2240,7 @@ void back_handle_st_req(struct stream *s)
*/ */
void back_handle_st_con(struct stream *s) void back_handle_st_con(struct stream *s)
{ {
struct stconn *cs = s->csb; struct stconn *cs = s->scb;
struct channel *req = &s->req; struct channel *req = &s->req;
struct channel *rep = &s->res; struct channel *rep = &s->res;
@ -2289,7 +2289,7 @@ void back_handle_st_con(struct stream *s)
*/ */
void back_handle_st_cer(struct stream *s) void back_handle_st_cer(struct stream *s)
{ {
struct stconn *cs = s->csb; struct stconn *cs = s->scb;
int must_tar = sc_ep_test(cs, SE_FL_ERROR); int must_tar = sc_ep_test(cs, SE_FL_ERROR);
DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s); DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
@ -2437,7 +2437,7 @@ void back_handle_st_cer(struct stream *s)
*/ */
void back_handle_st_rdy(struct stream *s) void back_handle_st_rdy(struct stream *s)
{ {
struct stconn *cs = s->csb; struct stconn *cs = s->scb;
struct channel *req = &s->req; struct channel *req = &s->req;
struct channel *rep = &s->res; struct channel *rep = &s->res;
@ -2447,7 +2447,7 @@ void back_handle_st_rdy(struct stream *s)
/* 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. * CS_ST_RDY state when the appctx was created.
*/ */
BUG_ON(!cs_appctx(s->csb)); BUG_ON(!cs_appctx(s->scb));
if (tv_iszero(&s->logs.tv_request)) if (tv_iszero(&s->logs.tv_request))
s->logs.tv_request = now; s->logs.tv_request = now;

4
src/cache.c
View File

@ -1840,7 +1840,7 @@ enum act_return http_action_req_cache_use(struct act_rule *rule, struct proxy *p
} }
s->target = &http_cache_applet.obj_type; s->target = &http_cache_applet.obj_type;
if ((appctx = cs_applet_create(s->csb, objt_applet(s->target)))) { if ((appctx = cs_applet_create(s->scb, objt_applet(s->target)))) {
struct cache_appctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx)); struct cache_appctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx));
appctx->st0 = HTX_CACHE_INIT; appctx->st0 = HTX_CACHE_INIT;
@ -2691,7 +2691,7 @@ smp_fetch_res_cache_name(const struct arg *args, struct sample *smp,
return 0; return 0;
/* Get appctx from the stream connector. */ /* Get appctx from the stream connector. */
appctx = cs_appctx(smp->strm->csb); appctx = cs_appctx(smp->strm->scb);
if (appctx && appctx->rule) { if (appctx && appctx->rule) {
cconf = appctx->rule->arg.act.p[0]; cconf = appctx->rule->arg.act.p[0];
if (cconf) { if (cconf) {

24
src/cli.c
View File

@ -2176,7 +2176,7 @@ static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, v
void pcli_write_prompt(struct stream *s) void pcli_write_prompt(struct stream *s)
{ {
struct buffer *msg = get_trash_chunk(); struct buffer *msg = get_trash_chunk();
struct channel *oc = cs_oc(s->csf); struct channel *oc = cs_oc(s->scf);
if (!(s->pcli_flags & PCLI_F_PROMPT)) if (!(s->pcli_flags & PCLI_F_PROMPT))
return; return;
@ -2704,9 +2704,9 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
pcli_write_prompt(s); pcli_write_prompt(s);
s->csb->flags |= CS_FL_NOLINGER | CS_FL_NOHALF; s->scb->flags |= CS_FL_NOLINGER | CS_FL_NOHALF;
cs_shutr(s->csb); cs_shutr(s->scb);
cs_shutw(s->csb); cs_shutw(s->scb);
/* /*
* starting from there this the same code as * starting from there this the same code as
@ -2773,22 +2773,22 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
/* only release our endpoint if we don't intend to reuse the /* only release our endpoint if we don't intend to reuse the
* connection. * connection.
*/ */
if (!cs_conn_ready(s->csb)) { if (!cs_conn_ready(s->scb)) {
s->srv_conn = NULL; s->srv_conn = NULL;
if (cs_reset_endp(s->csb) < 0) { if (cs_reset_endp(s->scb) < 0) {
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;
if (s->srv_error) if (s->srv_error)
s->srv_error(s, s->csb); s->srv_error(s, s->scb);
return 1; return 1;
} }
se_fl_clr(s->csb->sedesc, ~SE_FL_DETACHED); se_fl_clr(s->scb->sedesc, ~SE_FL_DETACHED);
} }
sockaddr_free(&s->csb->dst); sockaddr_free(&s->scb->dst);
cs_set_state(s->csb, CS_ST_INI); cs_set_state(s->scb, CS_ST_INI);
s->csb->flags &= CS_FL_ISBACK | CS_FL_DONT_WAKE; /* we're in the context of process_stream */ s->scb->flags &= CS_FL_ISBACK | CS_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);
s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST); s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
@ -2843,7 +2843,7 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
s->res.rex = TICK_ETERNITY; s->res.rex = TICK_ETERNITY;
s->res.wex = TICK_ETERNITY; s->res.wex = TICK_ETERNITY;
s->res.analyse_exp = TICK_ETERNITY; s->res.analyse_exp = TICK_ETERNITY;
s->csb->hcto = TICK_ETERNITY; s->scb->hcto = TICK_ETERNITY;
/* we're removing the analysers, we MUST re-enable events detection. /* we're removing the analysers, we MUST re-enable events detection.
* We don't enable close on the response channel since it's either * We don't enable close on the response channel since it's either

14
src/connection.c
View File

@ -1826,8 +1826,8 @@ static int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct
memcpy(hdr->sig, pp2_signature, PP2_SIGNATURE_LEN); memcpy(hdr->sig, pp2_signature, PP2_SIGNATURE_LEN);
if (strm) { if (strm) {
src = cs_src(strm->csf); src = cs_src(strm->scf);
dst = cs_dst(strm->csf); dst = cs_dst(strm->scf);
} }
else if (remote && conn_get_src(remote) && conn_get_dst(remote)) { else if (remote && conn_get_src(remote) && conn_get_dst(remote)) {
src = conn_src(remote); src = conn_src(remote);
@ -2025,8 +2025,8 @@ int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connectio
const struct sockaddr_storage *dst = NULL; const struct sockaddr_storage *dst = NULL;
if (strm) { if (strm) {
src = cs_src(strm->csf); src = cs_src(strm->scf);
dst = cs_dst(strm->csf); dst = cs_dst(strm->scf);
} }
else if (remote && conn_get_src(remote) && conn_get_dst(remote)) { else if (remote && conn_get_src(remote) && conn_get_dst(remote)) {
src = conn_src(remote); src = conn_src(remote);
@ -2106,7 +2106,7 @@ smp_fetch_fc_http_major(const struct arg *args, struct sample *smp, const char *
conn = (kw[0] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[0] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
/* No connection or a connection with a RAW muxx */ /* No connection or a connection with a RAW muxx */
if (!conn || (conn->mux && !(conn->mux->flags & MX_FL_HTX))) if (!conn || (conn->mux && !(conn->mux->flags & MX_FL_HTX)))
@ -2203,7 +2203,7 @@ int smp_fetch_fc_err(const struct arg *args, struct sample *smp, const char *kw,
conn = (kw[0] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[0] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
if (!conn) if (!conn)
return 0; return 0;
@ -2230,7 +2230,7 @@ int smp_fetch_fc_err_str(const struct arg *args, struct sample *smp, const char
conn = (kw[0] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[0] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
if (!conn) if (!conn)
return 0; return 0;

10
src/debug.c
View File

@ -694,7 +694,7 @@ static int debug_parse_cli_stream(char **args, char *payload, struct appctx *app
if (!*args[3]) { if (!*args[3]) {
return cli_err(appctx, return cli_err(appctx,
"Usage: debug dev stream { <obj> <op> <value> | wake }*\n" "Usage: debug dev stream { <obj> <op> <value> | wake }*\n"
" <obj> = {strm | strm.f | strm.x | csf.s | csb.s |\n" " <obj> = {strm | strm.f | strm.x | scf.s | scb.s |\n"
" txn.f | req.f | req.r | req.w | res.f | res.r | res.w}\n" " txn.f | req.f | req.r | req.w | res.f | res.r | res.w}\n"
" <op> = {'' (show) | '=' (assign) | '^' (xor) | '+' (or) | '-' (andnot)}\n" " <op> = {'' (show) | '=' (assign) | '^' (xor) | '+' (or) | '-' (andnot)}\n"
" <value> = 'now' | 64-bit dec/hex integer (0x prefix supported)\n" " <value> = 'now' | 64-bit dec/hex integer (0x prefix supported)\n"
@ -729,10 +729,10 @@ static int debug_parse_cli_stream(char **args, char *payload, struct appctx *app
ptr = (!s || !may_access(s)) ? NULL : &s->req.wex; size = sizeof(s->req.wex); ptr = (!s || !may_access(s)) ? NULL : &s->req.wex; size = sizeof(s->req.wex);
} else if (isteq(name, ist("res.w"))) { } else if (isteq(name, ist("res.w"))) {
ptr = (!s || !may_access(s)) ? NULL : &s->res.wex; size = sizeof(s->res.wex); ptr = (!s || !may_access(s)) ? NULL : &s->res.wex; size = sizeof(s->res.wex);
} else if (isteq(name, ist("csf.s"))) { } else if (isteq(name, ist("scf.s"))) {
ptr = (!s || !may_access(s)) ? NULL : &s->csf->state; size = sizeof(s->csf->state); ptr = (!s || !may_access(s)) ? NULL : &s->scf->state; size = sizeof(s->scf->state);
} else if (isteq(name, ist("csb.s"))) { } else if (isteq(name, ist("scb.s"))) {
ptr = (!s || !may_access(s)) ? NULL : &s->csf->state; size = sizeof(s->csb->state); ptr = (!s || !may_access(s)) ? NULL : &s->scf->state; size = sizeof(s->scb->state);
} else if (isteq(name, ist("wake"))) { } else if (isteq(name, ist("wake"))) {
if (s && may_access(s) && may_access((void *)s + sizeof(*s) - 1)) if (s && may_access(s) && may_access((void *)s + sizeof(*s) - 1))
task_wakeup(s->task, TASK_WOKEN_TIMER|TASK_WOKEN_IO|TASK_WOKEN_MSG); task_wakeup(s->task, TASK_WOKEN_TIMER|TASK_WOKEN_IO|TASK_WOKEN_MSG);

4
src/dns.c
View File

@ -828,8 +828,8 @@ static int dns_session_init(struct appctx *appctx)
goto error; goto error;
s = appctx_strm(appctx); s = appctx_strm(appctx);
s->csb->dst = addr; s->scb->dst = addr;
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
s->target = &ds->dss->srv->obj_type; s->target = &ds->dss->srv->obj_type;
s->flags = SF_ASSIGNED; s->flags = SF_ASSIGNED;

2
src/flt_spoe.c
View File

@ -1241,7 +1241,7 @@ spoe_init_appctx(struct appctx *appctx)
stream_set_backend(s, agent->b.be); stream_set_backend(s, agent->b.be);
/* applet is waiting for data */ /* applet is waiting for data */
cs_cant_get(s->csf); cs_cant_get(s->scf);
s->do_log = NULL; s->do_log = NULL;
s->res.flags |= CF_READ_DONTWAIT; s->res.flags |= CF_READ_DONTWAIT;

8
src/frontend.c
View File

@ -62,7 +62,7 @@ int frontend_accept(struct stream *s)
s->do_log(s); s->do_log(s);
} }
else if (conn) { else if (conn) {
src = cs_src(s->csf); src = cs_src(s->scf);
if (!src) if (!src)
send_log(fe, LOG_INFO, "Connect from unknown source to listener %d (%s/%s)\n", send_log(fe, LOG_INFO, "Connect from unknown source to listener %d (%s/%s)\n",
l->luid, fe->id, (fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP"); l->luid, fe->id, (fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
@ -73,7 +73,7 @@ int frontend_accept(struct stream *s)
switch (addr_to_str(src, pn, sizeof(pn))) { switch (addr_to_str(src, pn, sizeof(pn))) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
dst = cs_dst(s->csf); dst = cs_dst(s->scf);
if (dst) { if (dst) {
addr_to_str(dst, sn, sizeof(sn)); addr_to_str(dst, sn, sizeof(sn));
port = get_host_port(dst); port = get_host_port(dst);
@ -105,7 +105,7 @@ int frontend_accept(struct stream *s)
int alpn_len; int alpn_len;
/* try to report the ALPN value when available (also works for NPN) */ /* try to report the ALPN value when available (also works for NPN) */
if (conn == cs_conn(s->csf)) { if (conn == cs_conn(s->scf)) {
if (conn_get_alpn(conn, &alpn_str, &alpn_len) && alpn_str) { if (conn_get_alpn(conn, &alpn_str, &alpn_len) && alpn_str) {
int len = MIN(alpn_len, sizeof(alpn) - 1); int len = MIN(alpn_len, sizeof(alpn) - 1);
memcpy(alpn, alpn_str, len); memcpy(alpn, alpn_str, len);
@ -113,7 +113,7 @@ int frontend_accept(struct stream *s)
} }
} }
src = cs_src(s->csf); src = cs_src(s->scf);
if (!src) { if (!src) {
chunk_printf(&trash, "%08x:%s.accept(%04x)=%04x from [listener:%d] ALPN=%s\n", chunk_printf(&trash, "%08x:%s.accept(%04x)=%04x from [listener:%d] ALPN=%s\n",
s->uniq_id, fe->id, (unsigned short)l->rx.fd, (unsigned short)conn->handle.fd, s->uniq_id, fe->id, (unsigned short)l->rx.fd, (unsigned short)conn->handle.fd,

10
src/hlua.c
View File

@ -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->csb, CS_ST_ASS); cs_set_state(s->scb, CS_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;
@ -2678,7 +2678,7 @@ static int hlua_socket_getsockname(struct lua_State *L)
appctx = container_of(peer, struct hlua_csk_ctx, xref)->appctx; appctx = container_of(peer, struct hlua_csk_ctx, xref)->appctx;
s = appctx_strm(appctx); s = appctx_strm(appctx);
conn = cs_conn(s->csb); conn = cs_conn(s->scb);
if (!conn || !conn_get_src(conn)) { if (!conn || !conn_get_src(conn)) {
xref_unlock(&socket->xref, peer); xref_unlock(&socket->xref, peer);
lua_pushnil(L); lua_pushnil(L);
@ -2747,7 +2747,7 @@ __LJMP static int hlua_socket_connect_yield(struct lua_State *L, int status, lua
return 2; return 2;
} }
appctx = __cs_appctx(s->csf); appctx = __cs_appctx(s->scf);
/* Check for connection established. */ /* Check for connection established. */
if (csk_ctx->connected) { if (csk_ctx->connected) {
@ -2858,8 +2858,8 @@ __LJMP static int hlua_socket_connect(struct lua_State *L)
/* inform the stream that we want to be notified whenever the /* inform the stream that we want to be notified whenever the
* connection completes. * connection completes.
*/ */
cs_cant_get(s->csf); cs_cant_get(s->scf);
cs_rx_endp_more(s->csf); cs_rx_endp_more(s->scf);
appctx_wakeup(appctx); appctx_wakeup(appctx);
hlua->gc_count++; hlua->gc_count++;

46
src/http_ana.c
View File

@ -430,7 +430,7 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
*/ */
if (!s->target && http_stats_check_uri(s, txn, px)) { if (!s->target && http_stats_check_uri(s, txn, px)) {
s->target = &http_stats_applet.obj_type; s->target = &http_stats_applet.obj_type;
if (unlikely(!cs_applet_create(s->csb, objt_applet(s->target)))) { if (unlikely(!cs_applet_create(s->scb, objt_applet(s->target)))) {
s->logs.tv_request = now; s->logs.tv_request = now;
if (!(s->flags & SF_ERR_MASK)) if (!(s->flags & SF_ERR_MASK))
s->flags |= SF_ERR_RESOURCE; s->flags |= SF_ERR_RESOURCE;
@ -662,7 +662,7 @@ int http_process_request(struct stream *s, struct channel *req, int an_bit)
* asks for it. * asks for it.
*/ */
if ((sess->fe->options | s->be->options) & PR_O_FWDFOR) { if ((sess->fe->options | s->be->options) & PR_O_FWDFOR) {
const struct sockaddr_storage *src = cs_src(s->csf); const struct sockaddr_storage *src = cs_src(s->scf);
struct http_hdr_ctx ctx = { .blk = NULL }; struct http_hdr_ctx ctx = { .blk = NULL };
struct ist hdr = isttest(s->be->fwdfor_hdr_name) ? s->be->fwdfor_hdr_name : sess->fe->fwdfor_hdr_name; struct ist hdr = isttest(s->be->fwdfor_hdr_name) ? s->be->fwdfor_hdr_name : sess->fe->fwdfor_hdr_name;
@ -719,7 +719,7 @@ int http_process_request(struct stream *s, struct channel *req, int an_bit)
* asks for it. * asks for it.
*/ */
if ((sess->fe->options | s->be->options) & PR_O_ORGTO) { if ((sess->fe->options | s->be->options) & PR_O_ORGTO) {
const struct sockaddr_storage *dst = cs_dst(s->csf); const struct sockaddr_storage *dst = cs_dst(s->scf);
struct ist hdr = isttest(s->be->orgto_hdr_name) ? s->be->orgto_hdr_name : sess->fe->orgto_hdr_name; struct ist hdr = isttest(s->be->orgto_hdr_name) ? s->be->orgto_hdr_name : sess->fe->orgto_hdr_name;
if (dst && dst->ss_family == AF_INET) { if (dst && dst->ss_family == AF_INET) {
@ -1119,7 +1119,7 @@ int http_request_forward_body(struct stream *s, struct channel *req, int an_bit)
if (s->be->options & PR_O_ABRT_CLOSE) { if (s->be->options & PR_O_ABRT_CLOSE) {
channel_auto_read(req); channel_auto_read(req);
if ((req->flags & (CF_SHUTR|CF_READ_NULL)) && !(txn->flags & TX_CON_WANT_TUN)) if ((req->flags & (CF_SHUTR|CF_READ_NULL)) && !(txn->flags & TX_CON_WANT_TUN))
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
channel_auto_close(req); channel_auto_close(req);
} }
else if (s->txn->meth == HTTP_METH_POST) { else if (s->txn->meth == HTTP_METH_POST) {
@ -1263,7 +1263,7 @@ static __inline int do_l7_retry(struct stream *s, struct stconn *cs)
res->analyse_exp = TICK_ETERNITY; res->analyse_exp = TICK_ETERNITY;
res->total = 0; res->total = 0;
if (cs_reset_endp(s->csb) < 0) { if (cs_reset_endp(s->scb) < 0) {
if (!(s->flags & SF_ERR_MASK)) if (!(s->flags & SF_ERR_MASK))
s->flags |= SF_ERR_INTERNAL; s->flags |= SF_ERR_INTERNAL;
return -1; return -1;
@ -1335,13 +1335,13 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
if (unlikely(htx_is_empty(htx) || htx->first == -1)) { if (unlikely(htx_is_empty(htx) || htx->first == -1)) {
/* 1: have we encountered a read error ? */ /* 1: have we encountered a read error ? */
if (rep->flags & CF_READ_ERROR) { if (rep->flags & CF_READ_ERROR) {
struct connection *conn = cs_conn(s->csb); struct connection *conn = cs_conn(s->scb);
/* Perform a L7 retry because server refuses the early data. */ /* Perform a L7 retry because server refuses the early data. */
if ((txn->flags & TX_L7_RETRY) && if ((txn->flags & TX_L7_RETRY) &&
(s->be->retry_type & PR_RE_EARLY_ERROR) && (s->be->retry_type & PR_RE_EARLY_ERROR) &&
conn && conn->err_code == CO_ER_SSL_EARLY_FAILED && conn && conn->err_code == CO_ER_SSL_EARLY_FAILED &&
do_l7_retry(s, s->csb) == 0) { do_l7_retry(s, s->scb) == 0) {
DBG_TRACE_DEVEL("leaving on L7 retry", DBG_TRACE_DEVEL("leaving on L7 retry",
STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn); STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn);
return 0; return 0;
@ -1364,7 +1364,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
stream_inc_http_fail_ctr(s); stream_inc_http_fail_ctr(s);
} }
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
http_reply_and_close(s, txn->status, http_error_message(s)); http_reply_and_close(s, txn->status, http_error_message(s));
if (!(s->flags & SF_ERR_MASK)) if (!(s->flags & SF_ERR_MASK))
@ -1380,7 +1380,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
else if (rep->flags & CF_READ_TIMEOUT) { else if (rep->flags & CF_READ_TIMEOUT) {
if ((txn->flags & TX_L7_RETRY) && if ((txn->flags & TX_L7_RETRY) &&
(s->be->retry_type & PR_RE_TIMEOUT)) { (s->be->retry_type & PR_RE_TIMEOUT)) {
if (co_data(rep) || do_l7_retry(s, s->csb) == 0) { if (co_data(rep) || do_l7_retry(s, s->scb) == 0) {
DBG_TRACE_DEVEL("leaving on L7 retry", DBG_TRACE_DEVEL("leaving on L7 retry",
STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn); STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn);
return 0; return 0;
@ -1394,7 +1394,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
txn->status = 504; txn->status = 504;
stream_inc_http_fail_ctr(s); stream_inc_http_fail_ctr(s);
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
http_reply_and_close(s, txn->status, http_error_message(s)); http_reply_and_close(s, txn->status, http_error_message(s));
if (!(s->flags & SF_ERR_MASK)) if (!(s->flags & SF_ERR_MASK))
@ -1433,7 +1433,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
else if (rep->flags & CF_SHUTR) { else if (rep->flags & CF_SHUTR) {
if ((txn->flags & TX_L7_RETRY) && if ((txn->flags & TX_L7_RETRY) &&
(s->be->retry_type & PR_RE_DISCONNECTED)) { (s->be->retry_type & PR_RE_DISCONNECTED)) {
if (co_data(rep) || do_l7_retry(s, s->csb) == 0) { if (co_data(rep) || do_l7_retry(s, s->scb) == 0) {
DBG_TRACE_DEVEL("leaving on L7 retry", DBG_TRACE_DEVEL("leaving on L7 retry",
STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn); STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn);
return 0; return 0;
@ -1451,7 +1451,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
txn->status = 502; txn->status = 502;
stream_inc_http_fail_ctr(s); stream_inc_http_fail_ctr(s);
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
http_reply_and_close(s, txn->status, http_error_message(s)); http_reply_and_close(s, txn->status, http_error_message(s));
if (!(s->flags & SF_ERR_MASK)) if (!(s->flags & SF_ERR_MASK))
@ -1501,7 +1501,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
/* Perform a L7 retry because of the status code */ /* Perform a L7 retry because of the status code */
if ((txn->flags & TX_L7_RETRY) && if ((txn->flags & TX_L7_RETRY) &&
l7_status_match(s->be, sl->info.res.status) && l7_status_match(s->be, sl->info.res.status) &&
do_l7_retry(s, s->csb) == 0) { do_l7_retry(s, s->scb) == 0) {
DBG_TRACE_DEVEL("leaving on L7 retry", STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn); DBG_TRACE_DEVEL("leaving on L7 retry", STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn);
return 0; return 0;
} }
@ -1666,7 +1666,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
/* check for NTML authentication headers in 401 (WWW-Authenticate) and /* check for NTML authentication headers in 401 (WWW-Authenticate) and
* 407 (Proxy-Authenticate) responses and set the connection to private * 407 (Proxy-Authenticate) responses and set the connection to private
*/ */
srv_conn = cs_conn(s->csb); srv_conn = cs_conn(s->scb);
if (srv_conn) { if (srv_conn) {
struct ist hdr; struct ist hdr;
struct http_hdr_ctx ctx; struct http_hdr_ctx ctx;
@ -1729,7 +1729,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
} }
if ((s->be->retry_type & PR_RE_JUNK_REQUEST) && if ((s->be->retry_type & PR_RE_JUNK_REQUEST) &&
(txn->flags & TX_L7_RETRY) && (txn->flags & TX_L7_RETRY) &&
do_l7_retry(s, s->csb) == 0) { do_l7_retry(s, s->scb) == 0) {
DBG_TRACE_DEVEL("leaving on L7 retry", DBG_TRACE_DEVEL("leaving on L7 retry",
STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn); STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn);
return 0; return 0;
@ -1746,7 +1746,7 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
if (!(s->flags & SF_FINST_MASK)) if (!(s->flags & SF_FINST_MASK))
s->flags |= SF_FINST_H; s->flags |= SF_FINST_H;
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
DBG_TRACE_DEVEL("leaving on error", DBG_TRACE_DEVEL("leaving on error",
STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_HTTP_ERR, s, txn); STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_HTTP_ERR, s, txn);
return 0; return 0;
@ -2056,7 +2056,7 @@ int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, s
return_prx_cond: return_prx_cond:
s->logs.t_data = -1; /* was not a valid response */ s->logs.t_data = -1; /* was not a valid response */
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
if (!(s->flags & SF_ERR_MASK)) if (!(s->flags & SF_ERR_MASK))
s->flags |= SF_ERR_PRXCOND; s->flags |= SF_ERR_PRXCOND;
@ -3973,7 +3973,7 @@ static int http_handle_stats(struct stream *s, struct channel *req)
struct http_msg *msg = &txn->req; struct http_msg *msg = &txn->req;
struct uri_auth *uri_auth = s->be->uri_auth; struct uri_auth *uri_auth = s->be->uri_auth;
const char *h, *lookup, *end; const char *h, *lookup, *end;
struct appctx *appctx = __cs_appctx(s->csb); struct appctx *appctx = __cs_appctx(s->scb);
struct show_stat_ctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx)); struct show_stat_ctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx));
struct htx *htx; struct htx *htx;
struct htx_sl *sl; struct htx_sl *sl;
@ -4372,7 +4372,7 @@ static void http_end_request(struct stream *s)
/* if the server closes the connection, we want to immediately react /* if the server closes the connection, we want to immediately react
* and close the socket to save packets and syscalls. * and close the socket to save packets and syscalls.
*/ */
s->csb->flags |= CS_FL_NOHALF; s->scb->flags |= CS_FL_NOHALF;
/* In any case we've finished parsing the request so we must /* In any case we've finished parsing the request so we must
* disable Nagle when sending data because 1) we're not going * disable Nagle when sending data because 1) we're not going
@ -4447,7 +4447,7 @@ static void http_end_request(struct stream *s)
http_msg_closed: http_msg_closed:
/* if we don't know whether the server will close, we need to hard close */ /* if we don't know whether the server will close, we need to hard close */
if (txn->rsp.flags & HTTP_MSGF_XFER_LEN) if (txn->rsp.flags & HTTP_MSGF_XFER_LEN)
s->csb->flags |= CS_FL_NOLINGER; /* we want to close ASAP */ s->scb->flags |= CS_FL_NOLINGER; /* we want to close ASAP */
/* see above in MSG_DONE why we only do this in these states */ /* see above in MSG_DONE why we only do this in these states */
if (!(s->be->options & PR_O_ABRT_CLOSE)) if (!(s->be->options & PR_O_ABRT_CLOSE))
channel_dont_read(chn); channel_dont_read(chn);
@ -5098,7 +5098,7 @@ static void http_debug_stline(const char *dir, struct stream *s, const struct ht
chunk_printf(&trash, "%08x:%s.%s[%04x:%04x]: ", s->uniq_id, s->be->id, chunk_printf(&trash, "%08x:%s.%s[%04x:%04x]: ", s->uniq_id, s->be->id,
dir, dir,
objt_conn(sess->origin) ? (unsigned short)__objt_conn(sess->origin)->handle.fd : -1, objt_conn(sess->origin) ? (unsigned short)__objt_conn(sess->origin)->handle.fd : -1,
cs_conn(s->csb) ? (unsigned short)(__cs_conn(s->csb))->handle.fd : -1); cs_conn(s->scb) ? (unsigned short)(__cs_conn(s->scb))->handle.fd : -1);
max = HTX_SL_P1_LEN(sl); max = HTX_SL_P1_LEN(sl);
UBOUND(max, trash.size - trash.data - 3); UBOUND(max, trash.size - trash.data - 3);
@ -5129,7 +5129,7 @@ static void http_debug_hdr(const char *dir, struct stream *s, const struct ist n
chunk_printf(&trash, "%08x:%s.%s[%04x:%04x]: ", s->uniq_id, s->be->id, chunk_printf(&trash, "%08x:%s.%s[%04x:%04x]: ", s->uniq_id, s->be->id,
dir, dir,
objt_conn(sess->origin) ? (unsigned short)__objt_conn(sess->origin)->handle.fd : -1, objt_conn(sess->origin) ? (unsigned short)__objt_conn(sess->origin)->handle.fd : -1,
cs_conn(s->csb) ? (unsigned short)(__cs_conn(s->csb))->handle.fd : -1); cs_conn(s->scb) ? (unsigned short)(__cs_conn(s->scb))->handle.fd : -1);
max = n.len; max = n.len;
UBOUND(max, trash.size - trash.data - 3); UBOUND(max, trash.size - trash.data - 3);
@ -5165,7 +5165,7 @@ void http_txn_reset_res(struct http_txn *txn)
struct http_txn *http_create_txn(struct stream *s) struct http_txn *http_create_txn(struct stream *s)
{ {
struct http_txn *txn; struct http_txn *txn;
struct stconn *cs = s->csf; struct stconn *cs = s->scf;
txn = pool_alloc(pool_head_http_txn); txn = pool_alloc(pool_head_http_txn);
if (!txn) if (!txn)

8
src/http_client.c
View File

@ -1007,20 +1007,20 @@ static int httpclient_applet_init(struct appctx *appctx)
if (doresolve) { if (doresolve) {
/* in order to do the set-dst we need to put the address on the front */ /* in order to do the set-dst we need to put the address on the front */
s->csf->dst = addr; s->scf->dst = addr;
} else { } else {
/* in cases we don't use the resolve we already have the address /* in cases we don't use the resolve we already have the address
* and must put it on the backend side, some of the cases are * and must put it on the backend side, some of the cases are
* not meant to be used on the frontend (sockpair, unix socket etc.) */ * not meant to be used on the frontend (sockpair, unix socket etc.) */
s->csb->dst = addr; s->scb->dst = addr;
} }
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
s->flags |= SF_ASSIGNED; s->flags |= SF_ASSIGNED;
s->res.flags |= CF_READ_DONTWAIT; s->res.flags |= CF_READ_DONTWAIT;
/* applet is waiting for data */ /* applet is waiting for data */
cs_cant_get(s->csf); cs_cant_get(s->scf);
appctx_wakeup(appctx); appctx_wakeup(appctx);
hc->appctx = appctx; hc->appctx = appctx;

4
src/http_fetch.c
View File

@ -1186,7 +1186,7 @@ static int smp_fetch_base32(const struct arg *args, struct sample *smp, const ch
*/ */
static int smp_fetch_base32_src(const struct arg *args, struct sample *smp, const char *kw, void *private) static int smp_fetch_base32_src(const struct arg *args, struct sample *smp, const char *kw, void *private)
{ {
const struct sockaddr_storage *src = (smp->strm ? cs_src(smp->strm->csf) : NULL); const struct sockaddr_storage *src = (smp->strm ? cs_src(smp->strm->scf) : NULL);
struct buffer *temp; struct buffer *temp;
if (!src) if (!src)
@ -2053,7 +2053,7 @@ static int smp_fetch_url32(const struct arg *args, struct sample *smp, const cha
*/ */
static int smp_fetch_url32_src(const struct arg *args, struct sample *smp, const char *kw, void *private) static int smp_fetch_url32_src(const struct arg *args, struct sample *smp, const char *kw, void *private)
{ {
const struct sockaddr_storage *src = (smp->strm ? cs_src(smp->strm->csf) : NULL); const struct sockaddr_storage *src = (smp->strm ? cs_src(smp->strm->scf) : NULL);
struct buffer *temp; struct buffer *temp;
if (!src) if (!src)

10
src/log.c
View File

@ -1982,7 +1982,7 @@ int sess_build_logline(struct session *sess, struct stream *s, char *dst, size_t
if (likely(s)) { if (likely(s)) {
be = s->be; be = s->be;
txn = s->txn; txn = s->txn;
be_conn = cs_conn(s->csb); be_conn = cs_conn(s->scb);
status = (txn ? txn->status : 0); status = (txn ? txn->status : 0);
s_flags = s->flags; s_flags = s->flags;
uniq_id = s->uniq_id; uniq_id = s->uniq_id;
@ -2114,7 +2114,7 @@ int sess_build_logline(struct session *sess, struct stream *s, char *dst, size_t
break; break;
case LOG_FMT_CLIENTIP: // %ci case LOG_FMT_CLIENTIP: // %ci
addr = (s ? cs_src(s->csf) : sess_src(sess)); addr = (s ? cs_src(s->scf) : sess_src(sess));
if (addr) if (addr)
ret = lf_ip(tmplog, (struct sockaddr *)addr, dst + maxsize - tmplog, tmp); ret = lf_ip(tmplog, (struct sockaddr *)addr, dst + maxsize - tmplog, tmp);
else else
@ -2127,7 +2127,7 @@ int sess_build_logline(struct session *sess, struct stream *s, char *dst, size_t
break; break;
case LOG_FMT_CLIENTPORT: // %cp case LOG_FMT_CLIENTPORT: // %cp
addr = (s ? cs_src(s->csf) : sess_src(sess)); addr = (s ? cs_src(s->scf) : sess_src(sess));
if (addr) { if (addr) {
/* sess->listener is always defined when the session's owner is an inbound connections */ /* sess->listener is always defined when the session's owner is an inbound connections */
if (addr->ss_family == AF_UNIX) if (addr->ss_family == AF_UNIX)
@ -2145,7 +2145,7 @@ int sess_build_logline(struct session *sess, struct stream *s, char *dst, size_t
break; break;
case LOG_FMT_FRONTENDIP: // %fi case LOG_FMT_FRONTENDIP: // %fi
addr = (s ? cs_dst(s->csf) : sess_dst(sess)); addr = (s ? cs_dst(s->scf) : sess_dst(sess));
if (addr) if (addr)
ret = lf_ip(tmplog, (struct sockaddr *)addr, dst + maxsize - tmplog, tmp); ret = lf_ip(tmplog, (struct sockaddr *)addr, dst + maxsize - tmplog, tmp);
else else
@ -2158,7 +2158,7 @@ int sess_build_logline(struct session *sess, struct stream *s, char *dst, size_t
break; break;
case LOG_FMT_FRONTENDPORT: // %fp case LOG_FMT_FRONTENDPORT: // %fp
addr = (s ? cs_dst(s->csf) : sess_dst(sess)); addr = (s ? cs_dst(s->scf) : sess_dst(sess));
if (addr) { if (addr) {
/* sess->listener is always defined when the session's owner is an inbound connections */ /* sess->listener is always defined when the session's owner is an inbound connections */
if (addr->ss_family == AF_UNIX) if (addr->ss_family == AF_UNIX)

12
src/mux_h2.c
View File

@ -5040,20 +5040,20 @@ static int h2_frt_transfer_data(struct h2s *h2s)
int block; int block;
unsigned int flen = 0; unsigned int flen = 0;
struct htx *htx = NULL; struct htx *htx = NULL;
struct buffer *csbuf; struct buffer *scbuf;
unsigned int sent; unsigned int sent;
TRACE_ENTER(H2_EV_RX_FRAME|H2_EV_RX_DATA, h2c->conn, h2s); TRACE_ENTER(H2_EV_RX_FRAME|H2_EV_RX_DATA, h2c->conn, h2s);
h2c->flags &= ~H2_CF_DEM_SFULL; h2c->flags &= ~H2_CF_DEM_SFULL;
csbuf = h2_get_buf(h2c, &h2s->rxbuf); scbuf = h2_get_buf(h2c, &h2s->rxbuf);
if (!csbuf) { if (!scbuf) {
h2c->flags |= H2_CF_DEM_SALLOC; h2c->flags |= H2_CF_DEM_SALLOC;
TRACE_STATE("waiting for an h2s rxbuf", H2_EV_RX_FRAME|H2_EV_RX_DATA|H2_EV_H2S_BLK, h2c->conn, h2s); TRACE_STATE("waiting for an h2s rxbuf", H2_EV_RX_FRAME|H2_EV_RX_DATA|H2_EV_H2S_BLK, h2c->conn, h2s);
goto fail; goto fail;
} }
htx = htx_from_buf(csbuf); htx = htx_from_buf(scbuf);
try_again: try_again:
flen = h2c->dfl - h2c->dpl; flen = h2c->dfl - h2c->dpl;
@ -5132,12 +5132,12 @@ try_again:
h2c->rcvd_s += h2c->dpl; h2c->rcvd_s += h2c->dpl;
h2c->dpl = 0; h2c->dpl = 0;
h2c->st0 = H2_CS_FRAME_A; // send the corresponding window update h2c->st0 = H2_CS_FRAME_A; // send the corresponding window update
htx_to_buf(htx, csbuf); htx_to_buf(htx, scbuf);
TRACE_LEAVE(H2_EV_RX_FRAME|H2_EV_RX_DATA, h2c->conn, h2s); TRACE_LEAVE(H2_EV_RX_FRAME|H2_EV_RX_DATA, h2c->conn, h2s);
return 1; return 1;
fail: fail:
if (htx) if (htx)
htx_to_buf(htx, csbuf); htx_to_buf(htx, scbuf);
TRACE_LEAVE(H2_EV_RX_FRAME|H2_EV_RX_DATA, h2c->conn, h2s); TRACE_LEAVE(H2_EV_RX_FRAME|H2_EV_RX_DATA, h2c->conn, h2s);
return 0; return 0;
} }

6
src/peers.c
View File

@ -1085,12 +1085,12 @@ static int peer_session_init(struct appctx *appctx)
s = appctx_strm(appctx); s = appctx_strm(appctx);
/* applet is waiting for data */ /* applet is waiting for data */
cs_cant_get(s->csf); cs_cant_get(s->scf);
appctx_wakeup(appctx); appctx_wakeup(appctx);
/* initiate an outgoing connection */ /* initiate an outgoing connection */
s->csb->dst = addr; s->scb->dst = addr;
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
s->flags = SF_ASSIGNED; s->flags = SF_ASSIGNED;
s->target = peer_session_target(peer, s); s->target = peer_session_target(peer, s);

6
src/proxy.c
View File

@ -2358,12 +2358,12 @@ int stream_set_backend(struct stream *s, struct proxy *be)
proxy_inc_be_ctr(be); proxy_inc_be_ctr(be);
/* assign new parameters to the stream from the new backend */ /* assign new parameters to the stream from the new backend */
s->csb->flags &= ~CS_FL_INDEP_STR; s->scb->flags &= ~CS_FL_INDEP_STR;
if (be->options2 & PR_O2_INDEPSTR) if (be->options2 & PR_O2_INDEPSTR)
s->csb->flags |= CS_FL_INDEP_STR; s->scb->flags |= CS_FL_INDEP_STR;
if (tick_isset(be->timeout.serverfin)) if (tick_isset(be->timeout.serverfin))
s->csb->hcto = be->timeout.serverfin; s->scb->hcto = be->timeout.serverfin;
/* We want to enable the backend-specific analysers except those which /* We want to enable the backend-specific analysers except those which
* were already run as part of the frontend/listener. Note that it would * were already run as part of the frontend/listener. Note that it would

2
src/queue.c
View File

@ -600,7 +600,7 @@ int pendconn_dequeue(struct stream *strm)
/* the entry might have been redistributed to another server */ /* the entry might have been redistributed to another server */
if (!(strm->flags & SF_ASSIGNED)) if (!(strm->flags & SF_ASSIGNED))
sockaddr_free(&strm->csb->dst); sockaddr_free(&strm->scb->dst);
if (p->target) { if (p->target) {
/* a server picked this pendconn, it must skip LB */ /* a server picked this pendconn, it must skip LB */

4
src/sink.c
View File

@ -607,8 +607,8 @@ static int sink_forward_session_init(struct appctx *appctx)
goto out_free_addr; goto out_free_addr;
s = appctx_strm(appctx); s = appctx_strm(appctx);
s->csb->dst = addr; s->scb->dst = addr;
s->csb->flags |= CS_FL_NOLINGER; s->scb->flags |= CS_FL_NOLINGER;
s->target = &sft->srv->obj_type; s->target = &sft->srv->obj_type;
s->flags = SF_ASSIGNED; s->flags = SF_ASSIGNED;

52
src/ssl_sample.c
View File

@ -526,7 +526,7 @@ smp_fetch_ssl_x_der(const struct arg *args, struct sample *smp, const char *kw,
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
@ -581,7 +581,7 @@ smp_fetch_ssl_x_chain_der(const struct arg *args, struct sample *smp, const char
int i; int i;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
@ -644,7 +644,7 @@ smp_fetch_ssl_x_serial(const struct arg *args, struct sample *smp, const char *k
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
@ -697,7 +697,7 @@ smp_fetch_ssl_x_sha1(const struct arg *args, struct sample *smp, const char *kw,
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
@ -748,7 +748,7 @@ smp_fetch_ssl_x_notafter(const struct arg *args, struct sample *smp, const char
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
@ -800,7 +800,7 @@ smp_fetch_ssl_x_i_dn(const struct arg *args, struct sample *smp, const char *kw,
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
@ -868,7 +868,7 @@ smp_fetch_ssl_x_notbefore(const struct arg *args, struct sample *smp, const char
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
@ -920,7 +920,7 @@ smp_fetch_ssl_x_s_dn(const struct arg *args, struct sample *smp, const char *kw,
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
@ -1017,7 +1017,7 @@ smp_fetch_ssl_x_version(const struct arg *args, struct sample *smp, const char *
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
@ -1062,7 +1062,7 @@ smp_fetch_ssl_x_sig_alg(const struct arg *args, struct sample *smp, const char *
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
@ -1119,7 +1119,7 @@ smp_fetch_ssl_x_key_alg(const struct arg *args, struct sample *smp, const char *
SSL *ssl; SSL *ssl;
if (conn_server) if (conn_server)
conn = smp->strm ? cs_conn(smp->strm->csb) : NULL; conn = smp->strm ? cs_conn(smp->strm->scb) : NULL;
else else
conn = objt_conn(smp->sess->origin); conn = objt_conn(smp->sess->origin);
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
@ -1171,7 +1171,7 @@ smp_fetch_ssl_fc(const struct arg *args, struct sample *smp, const char *kw, voi
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
smp->data.type = SMP_T_BOOL; smp->data.type = SMP_T_BOOL;
smp->data.u.sint = conn_is_ssl(conn); smp->data.u.sint = conn_is_ssl(conn);
@ -1208,7 +1208,7 @@ smp_fetch_ssl_fc_is_resumed(const struct arg *args, struct sample *smp, const ch
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
@ -1231,7 +1231,7 @@ smp_fetch_ssl_fc_cipher(const struct arg *args, struct sample *smp, const char *
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
smp->flags = 0; smp->flags = 0;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
@ -1265,7 +1265,7 @@ smp_fetch_ssl_fc_alg_keysize(const struct arg *args, struct sample *smp, const c
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
smp->flags = 0; smp->flags = 0;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
@ -1296,7 +1296,7 @@ smp_fetch_ssl_fc_use_keysize(const struct arg *args, struct sample *smp, const c
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
smp->flags = 0; smp->flags = 0;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
@ -1328,7 +1328,7 @@ smp_fetch_ssl_fc_npn(const struct arg *args, struct sample *smp, const char *kw,
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
if (!ssl) if (!ssl)
@ -1363,7 +1363,7 @@ smp_fetch_ssl_fc_alpn(const struct arg *args, struct sample *smp, const char *kw
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
if (!ssl) if (!ssl)
@ -1396,7 +1396,7 @@ smp_fetch_ssl_fc_protocol(const struct arg *args, struct sample *smp, const char
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
smp->flags = 0; smp->flags = 0;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
@ -1434,7 +1434,7 @@ smp_fetch_ssl_fc_session_id(const struct arg *args, struct sample *smp, const ch
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
if (!ssl) if (!ssl)
@ -1466,7 +1466,7 @@ smp_fetch_ssl_fc_random(const struct arg *args, struct sample *smp, const char *
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
if (!ssl) if (!ssl)
@ -1503,7 +1503,7 @@ smp_fetch_ssl_fc_session_key(const struct arg *args, struct sample *smp, const c
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);
if (!ssl) if (!ssl)
@ -1652,7 +1652,7 @@ smp_fetch_ssl_fc_err(const struct arg *args, struct sample *smp, const char *kw,
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
if (!conn) if (!conn)
return 0; return 0;
@ -1705,7 +1705,7 @@ smp_fetch_ssl_fc_err_str(const struct arg *args, struct sample *smp, const char
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
if (!conn) if (!conn)
return 0; return 0;
@ -1838,7 +1838,7 @@ static int smp_fetch_ssl_x_keylog(const struct arg *args, struct sample *smp, co
const char *sfx; const char *sfx;
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
if (!conn) if (!conn)
return 0; return 0;
@ -1935,7 +1935,7 @@ smp_fetch_ssl_fc_unique_id(const struct arg *args, struct sample *smp, const cha
conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL; conn = (kw[4] == 'b') ? cs_conn(__objt_check(smp->sess->origin)->cs) : NULL;
else else
conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) : conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(smp->strm->csb) : NULL; smp->strm ? cs_conn(smp->strm->scb) : NULL;
smp->flags = 0; smp->flags = 0;
ssl = ssl_sock_get_ssl_object(conn); ssl = ssl_sock_get_ssl_object(conn);

2
src/ssl_sock.c
View File

@ -7885,7 +7885,7 @@ enum act_return ssl_action_wait_for_hs(struct act_rule *rule, struct proxy *px,
struct stconn *cs; struct stconn *cs;
conn = objt_conn(sess->origin); conn = objt_conn(sess->origin);
cs = s->csf; cs = s->scf;
if (conn && cs) { if (conn && cs) {
if (conn->flags & (CO_FL_EARLY_SSL_HS | CO_FL_SSL_WAIT_HS)) { if (conn->flags & (CO_FL_EARLY_SSL_HS | CO_FL_SSL_WAIT_HS)) {

396
src/stream.c
View File

@ -173,7 +173,7 @@ static void strm_trace(enum trace_level level, uint64_t mask, const struct trace
/* Front and back stream connector state */ /* Front and back stream connector state */
chunk_appendf(&trace_buf, " CS=(%s,%s)", chunk_appendf(&trace_buf, " CS=(%s,%s)",
cs_state_str(s->csf->state), cs_state_str(s->csb->state)); cs_state_str(s->scf->state), cs_state_str(s->scb->state));
/* If txn is defined, HTTP req/rep states */ /* If txn is defined, HTTP req/rep states */
if (txn) if (txn)
@ -205,10 +205,10 @@ static void strm_trace(enum trace_level level, uint64_t mask, const struct trace
task, s, s->flags, s->conn_err_type, txn->flags, txn->req.flags, txn->rsp.flags, txn->status); task, s, s->flags, s->conn_err_type, txn->flags, txn->req.flags, txn->rsp.flags, txn->status);
} }
else { else {
chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x,0x%x) csf=(%p,%d,0x%08x) csb=(%p,%d,0x%08x) retries=%d", chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x,0x%x) scf=(%p,%d,0x%08x) scb=(%p,%d,0x%08x) retries=%d",
task, s, s->flags, s->conn_err_type, task, s, s->flags, s->conn_err_type,
s->csf, s->csf->state, s->csf->flags, s->scf, s->scf->state, s->scf->flags,
s->csb, s->csb->state, s->csb->flags, s->scb, s->scb->state, s->scb->flags,
s->conn_retries); s->conn_retries);
} }
@ -313,12 +313,12 @@ int stream_buf_available(void *arg)
{ {
struct stream *s = arg; struct stream *s = arg;
if (!s->req.buf.size && !s->req.pipe && sc_ep_test(s->csf, SE_FL_RXBLK_BUFF) && if (!s->req.buf.size && !s->req.pipe && sc_ep_test(s->scf, SE_FL_RXBLK_BUFF) &&
b_alloc(&s->req.buf)) b_alloc(&s->req.buf))
cs_rx_buff_rdy(s->csf); cs_rx_buff_rdy(s->scf);
else if (!s->res.buf.size && !s->res.pipe && sc_ep_test(s->csb, SE_FL_RXBLK_BUFF) && else if (!s->res.buf.size && !s->res.pipe && sc_ep_test(s->scb, SE_FL_RXBLK_BUFF) &&
b_alloc(&s->res.buf)) b_alloc(&s->res.buf))
cs_rx_buff_rdy(s->csb); cs_rx_buff_rdy(s->scb);
else else
return 0; return 0;
@ -445,23 +445,23 @@ struct stream *stream_new(struct session *sess, struct stconn *cs, struct buffer
if (sess->fe->mode == PR_MODE_HTTP) if (sess->fe->mode == PR_MODE_HTTP)
s->flags |= SF_HTX; s->flags |= SF_HTX;
s->csf = cs; s->scf = cs;
if (cs_attach_strm(s->csf, s) < 0) if (cs_attach_strm(s->scf, s) < 0)
goto out_fail_attach_csf; goto out_fail_attach_scf;
s->csb = cs_new_from_strm(s, CS_FL_ISBACK); s->scb = cs_new_from_strm(s, CS_FL_ISBACK);
if (!s->csb) if (!s->scb)
goto out_fail_alloc_csb; goto out_fail_alloc_scb;
cs_set_state(s->csf, CS_ST_EST); cs_set_state(s->scf, CS_ST_EST);
s->csf->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))
s->csf->flags |= CS_FL_INDEP_STR; s->scf->flags |= CS_FL_INDEP_STR;
s->csb->hcto = TICK_ETERNITY; s->scb->hcto = TICK_ETERNITY;
if (likely(sess->fe->options2 & PR_O2_INDEPSTR)) if (likely(sess->fe->options2 & PR_O2_INDEPSTR))
s->csb->flags |= CS_FL_INDEP_STR; s->scb->flags |= CS_FL_INDEP_STR;
if (sc_ep_test(cs, SE_FL_WEBSOCKET)) if (sc_ep_test(cs, SE_FL_WEBSOCKET))
s->flags |= SF_WEBSOCKET; s->flags |= SF_WEBSOCKET;
@ -537,7 +537,7 @@ struct stream *stream_new(struct session *sess, struct stconn *cs, struct buffer
/* finish initialization of the accepted file descriptor */ /* finish initialization of the accepted file descriptor */
if (cs_appctx(cs)) if (cs_appctx(cs))
cs_want_get(s->csf); cs_want_get(s->scf);
if (sess->fe->accept && sess->fe->accept(s) < 0) if (sess->fe->accept && sess->fe->accept(s) < 0)
goto out_fail_accept; goto out_fail_accept;
@ -567,9 +567,9 @@ struct stream *stream_new(struct session *sess, struct stconn *cs, struct buffer
out_fail_accept: out_fail_accept:
flt_stream_release(s, 0); flt_stream_release(s, 0);
LIST_DELETE(&s->list); LIST_DELETE(&s->list);
out_fail_attach_csf: out_fail_attach_scf:
cs_free(s->csb); cs_free(s->scb);
out_fail_alloc_csb: out_fail_alloc_scb:
task_destroy(t); task_destroy(t);
out_fail_alloc: out_fail_alloc:
pool_free(pool_head_stream, s); pool_free(pool_head_stream, s);
@ -708,8 +708,8 @@ void stream_free(struct stream *s)
} }
LIST_DELETE(&s->list); LIST_DELETE(&s->list);
cs_destroy(s->csb); cs_destroy(s->scb);
cs_destroy(s->csf); cs_destroy(s->scf);
pool_free(pool_head_stream, s); pool_free(pool_head_stream, s);
@ -873,7 +873,7 @@ int stream_set_timeout(struct stream *s, enum act_timeout_name name, int timeout
*/ */
static void back_establish(struct stream *s) static void back_establish(struct stream *s)
{ {
struct connection *conn = cs_conn(s->csb); struct connection *conn = cs_conn(s->scb);
struct channel *req = &s->req; struct channel *req = &s->req;
struct channel *rep = &s->res; struct channel *rep = &s->res;
@ -886,7 +886,7 @@ static void back_establish(struct stream *s)
s->flags &= ~SF_CONN_EXP; s->flags &= ~SF_CONN_EXP;
/* errors faced after sending data need to be reported */ /* errors faced after sending data need to be reported */
if (sc_ep_test(s->csb, SE_FL_ERROR) && req->flags & CF_WROTE_DATA) { if (sc_ep_test(s->scb, SE_FL_ERROR) && req->flags & CF_WROTE_DATA) {
/* Don't add CF_WRITE_ERROR if we're here because /* Don't add CF_WRITE_ERROR if we're here because
* early data were rejected by the server, or * early data were rejected by the server, or
* http_wait_for_response() will never be called * http_wait_for_response() will never be called
@ -917,7 +917,7 @@ static void back_establish(struct stream *s)
rep->analysers |= strm_fe(s)->fe_rsp_ana | s->be->be_rsp_ana; rep->analysers |= strm_fe(s)->fe_rsp_ana | s->be->be_rsp_ana;
cs_rx_endp_more(s->csb); cs_rx_endp_more(s->scb);
rep->flags |= CF_READ_ATTACHED; /* producer is now attached */ rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
if (conn) { if (conn) {
/* real connections have timeouts /* real connections have timeouts
@ -936,13 +936,13 @@ static void back_establish(struct stream *s)
* delayed recv here to give a chance to the data to flow back * delayed recv here to give a chance to the data to flow back
* by the time we process other tasks. * by the time we process other tasks.
*/ */
cs_chk_rcv(s->csb); cs_chk_rcv(s->scb);
} }
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 CS_ST_DIS now. */
if (rep->flags & (CF_SHUTR | CF_SHUTW)) { if (rep->flags & (CF_SHUTR | CF_SHUTW)) {
s->csb->state = CS_ST_DIS; s->scb->state = CS_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->csb->state == CS_ST_INI) { if (s->scb->state == CS_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->csb->state == CS_ST_QUE) else if (s->scb->state == CS_ST_QUE)
s->flags |= SF_FINST_Q; s->flags |= SF_FINST_Q;
else if (cs_state_in(s->csb->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, CS_SB_REQ|CS_SB_TAR|CS_SB_ASS|CS_SB_CON|CS_SB_CER|CS_SB_RDY))
s->flags |= SF_FINST_C; s->flags |= SF_FINST_C;
else if (s->csb->state == CS_ST_EST || s->prev_conn_state == CS_ST_EST) else if (s->scb->state == CS_ST_EST || s->prev_conn_state == CS_ST_EST)
s->flags |= SF_FINST_D; s->flags |= SF_FINST_D;
else else
s->flags |= SF_FINST_L; s->flags |= SF_FINST_L;
@ -992,7 +992,7 @@ enum act_return process_use_service(struct act_rule *rule, struct proxy *px,
if (flags & ACT_OPT_FIRST) { if (flags & ACT_OPT_FIRST) {
/* Register applet. this function schedules the applet. */ /* Register applet. this function schedules the applet. */
s->target = &rule->applet.obj_type; s->target = &rule->applet.obj_type;
appctx = cs_applet_create(s->csb, objt_applet(s->target)); appctx = cs_applet_create(s->scb, objt_applet(s->target));
if (unlikely(!appctx)) if (unlikely(!appctx))
return ACT_RET_ERR; return ACT_RET_ERR;
@ -1002,7 +1002,7 @@ enum act_return process_use_service(struct act_rule *rule, struct proxy *px,
return ACT_RET_ERR; return ACT_RET_ERR;
} }
else else
appctx = __cs_appctx(s->csb); appctx = __cs_appctx(s->scb);
if (rule->from != ACT_F_HTTP_REQ) { if (rule->from != ACT_F_HTTP_REQ) {
if (sess->fe == s->be) /* report it if the request was intercepted by the frontend */ if (sess->fe == s->be) /* report it if the request was intercepted by the frontend */
@ -1013,7 +1013,7 @@ enum act_return process_use_service(struct act_rule *rule, struct proxy *px,
} }
/* Now we can schedule the applet. */ /* Now we can schedule the applet. */
cs_cant_get(s->csb); cs_cant_get(s->scb);
appctx_wakeup(appctx); appctx_wakeup(appctx);
return ACT_RET_STOP; return ACT_RET_STOP;
} }
@ -1462,7 +1462,7 @@ static int process_store_rules(struct stream *s, struct channel *rep, int an_bit
*/ */
int stream_set_http_mode(struct stream *s, const struct mux_proto_list *mux_proto) int stream_set_http_mode(struct stream *s, const struct mux_proto_list *mux_proto)
{ {
struct stconn *cs = s->csf; struct stconn *cs = s->scf;
struct connection *conn; struct connection *conn;
/* Already an HTTP stream */ /* Already an HTTP stream */
@ -1476,13 +1476,13 @@ int stream_set_http_mode(struct stream *s, const struct mux_proto_list *mux_prot
conn = cs_conn(cs); conn = cs_conn(cs);
if (conn) { if (conn) {
cs_rx_endp_more(s->csf); cs_rx_endp_more(s->scf);
/* Make sure we're unsubscribed, the the new /* Make sure we're unsubscribed, the the new
* mux will probably want to subscribe to * mux will probably want to subscribe to
* the underlying XPRT * the underlying XPRT
*/ */
if (s->csf->wait_event.events) if (s->scf->wait_event.events)
conn->mux->unsubscribe(cs, s->csf->wait_event.events, &(s->csf->wait_event)); conn->mux->unsubscribe(cs, s->scf->wait_event.events, &(s->scf->wait_event));
if (conn->mux->flags & MX_FL_NO_UPG) if (conn->mux->flags & MX_FL_NO_UPG)
return 0; return 0;
@ -1522,35 +1522,35 @@ int stream_set_http_mode(struct stream *s, const struct mux_proto_list *mux_prot
*/ */
static void stream_update_both_cs(struct stream *s) static void stream_update_both_cs(struct stream *s)
{ {
struct stconn *csf = s->csf; struct stconn *scf = s->scf;
struct stconn *csb = s->csb; struct stconn *scb = s->scb;
struct channel *req = &s->req; struct channel *req = &s->req;
struct channel *res = &s->res; struct channel *res = &s->res;
req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_READ_ATTACHED|CF_WRITE_NULL|CF_WRITE_PARTIAL); req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_READ_ATTACHED|CF_WRITE_NULL|CF_WRITE_PARTIAL);
res->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_READ_ATTACHED|CF_WRITE_NULL|CF_WRITE_PARTIAL); res->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_READ_ATTACHED|CF_WRITE_NULL|CF_WRITE_PARTIAL);
s->prev_conn_state = csb->state; s->prev_conn_state = scb->state;
/* let's recompute both sides states */ /* let's recompute both sides states */
if (cs_state_in(csf->state, CS_SB_RDY|CS_SB_EST)) if (cs_state_in(scf->state, CS_SB_RDY|CS_SB_EST))
cs_update(csf); cs_update(scf);
if (cs_state_in(csb->state, CS_SB_RDY|CS_SB_EST)) if (cs_state_in(scb->state, CS_SB_RDY|CS_SB_EST))
cs_update(csb); 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
* handled at the latest moment. * handled at the latest moment.
*/ */
if (cs_appctx(csf)) { if (cs_appctx(scf)) {
if ((cs_rx_endp_ready(csf) && !cs_rx_blocked(csf)) || if ((cs_rx_endp_ready(scf) && !cs_rx_blocked(scf)) ||
(cs_tx_endp_ready(csf) && !cs_tx_blocked(csf))) (cs_tx_endp_ready(scf) && !cs_tx_blocked(scf)))
appctx_wakeup(__cs_appctx(csf)); appctx_wakeup(__cs_appctx(scf));
} }
if (cs_appctx(csb)) { if (cs_appctx(scb)) {
if ((cs_rx_endp_ready(csb) && !cs_rx_blocked(csb)) || if ((cs_rx_endp_ready(scb) && !cs_rx_blocked(scb)) ||
(cs_tx_endp_ready(csb) && !cs_tx_blocked(csb))) (cs_tx_endp_ready(scb) && !cs_tx_blocked(scb)))
appctx_wakeup(__cs_appctx(csb)); appctx_wakeup(__cs_appctx(scb));
} }
} }
@ -1620,7 +1620,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
unsigned int rp_cons_last, rp_prod_last; unsigned int rp_cons_last, rp_prod_last;
unsigned int req_ana_back; unsigned int req_ana_back;
struct channel *req, *res; struct channel *req, *res;
struct stconn *csf, *csb; struct stconn *scf, *scb;
unsigned int rate; unsigned int rate;
DBG_TRACE_ENTER(STRM_EV_STRM_PROC, s); DBG_TRACE_ENTER(STRM_EV_STRM_PROC, s);
@ -1630,12 +1630,12 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
req = &s->req; req = &s->req;
res = &s->res; res = &s->res;
csf = s->csf; scf = s->scf;
csb = s->csb; scb = s->scb;
/* First, attempt to receive pending data from I/O layers */ /* First, attempt to receive pending data from I/O layers */
cs_conn_sync_recv(csf); cs_conn_sync_recv(scf);
cs_conn_sync_recv(csb); cs_conn_sync_recv(scb);
/* Let's check if we're looping without making any progress, e.g. due /* Let's check if we're looping without making any progress, e.g. due
* to a bogus analyser or the fact that we're ignoring a read0. The * to a bogus analyser or the fact that we're ignoring a read0. The
@ -1660,8 +1660,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
rpf_last = res->flags & ~CF_MASK_ANALYSER; rpf_last = res->flags & ~CF_MASK_ANALYSER;
/* we don't want the stream connector functions to recursively wake us up */ /* we don't want the stream connector functions to recursively wake us up */
csf->flags |= CS_FL_DONT_WAKE; scf->flags |= CS_FL_DONT_WAKE;
csb->flags |= CS_FL_DONT_WAKE; scb->flags |= CS_FL_DONT_WAKE;
/* update pending events */ /* update pending events */
s->pending_events |= (state & TASK_WOKEN_ANY); s->pending_events |= (state & TASK_WOKEN_ANY);
@ -1681,27 +1681,27 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
channel_check_timeouts(req); channel_check_timeouts(req);
if (unlikely((req->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) { if (unlikely((req->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
csb->flags |= CS_FL_NOLINGER; scb->flags |= CS_FL_NOLINGER;
cs_shutw(csb); cs_shutw(scb);
} }
if (unlikely((req->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) { if (unlikely((req->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
if (csf->flags & CS_FL_NOHALF) if (scf->flags & CS_FL_NOHALF)
csf->flags |= CS_FL_NOLINGER; scf->flags |= CS_FL_NOLINGER;
cs_shutr(csf); cs_shutr(scf);
} }
channel_check_timeouts(res); channel_check_timeouts(res);
if (unlikely((res->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) { if (unlikely((res->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
csf->flags |= CS_FL_NOLINGER; scf->flags |= CS_FL_NOLINGER;
cs_shutw(csf); cs_shutw(scf);
} }
if (unlikely((res->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) { if (unlikely((res->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
if (csb->flags & CS_FL_NOHALF) if (scb->flags & CS_FL_NOHALF)
csb->flags |= CS_FL_NOLINGER; scb->flags |= CS_FL_NOLINGER;
cs_shutr(csb); cs_shutr(scb);
} }
if (HAS_FILTERS(s)) if (HAS_FILTERS(s))
@ -1716,10 +1716,10 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
(CF_SHUTR|CF_READ_ACTIVITY|CF_READ_TIMEOUT|CF_SHUTW| (CF_SHUTR|CF_READ_ACTIVITY|CF_READ_TIMEOUT|CF_SHUTW|
CF_WRITE_ACTIVITY|CF_WRITE_TIMEOUT|CF_ANA_TIMEOUT)) && CF_WRITE_ACTIVITY|CF_WRITE_TIMEOUT|CF_ANA_TIMEOUT)) &&
!(s->flags & SF_CONN_EXP) && !(s->flags & SF_CONN_EXP) &&
!((sc_ep_get(csf) | csb->flags) & SE_FL_ERROR) && !((sc_ep_get(scf) | scb->flags) & SE_FL_ERROR) &&
((s->pending_events & TASK_WOKEN_ANY) == TASK_WOKEN_TIMER)) { ((s->pending_events & TASK_WOKEN_ANY) == TASK_WOKEN_TIMER)) {
csf->flags &= ~CS_FL_DONT_WAKE; scf->flags &= ~CS_FL_DONT_WAKE;
csb->flags &= ~CS_FL_DONT_WAKE; scb->flags &= ~CS_FL_DONT_WAKE;
goto update_exp_and_leave; goto update_exp_and_leave;
} }
} }
@ -1735,10 +1735,10 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
* must be be reviewed too. * must be be reviewed too.
*/ */
if (!stream_alloc_work_buffer(s)) { if (!stream_alloc_work_buffer(s)) {
sc_ep_set(s->csf, SE_FL_ERROR); sc_ep_set(s->scf, SE_FL_ERROR);
s->conn_err_type = STRM_ET_CONN_RES; s->conn_err_type = STRM_ET_CONN_RES;
sc_ep_set(s->csb, SE_FL_ERROR); sc_ep_set(s->scb, SE_FL_ERROR);
s->conn_err_type = STRM_ET_CONN_RES; s->conn_err_type = STRM_ET_CONN_RES;
if (!(s->flags & SF_ERR_MASK)) if (!(s->flags & SF_ERR_MASK))
@ -1754,11 +1754,11 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
* connection setup code must be able to deal with any type of abort. * connection setup code must be able to deal with any type of abort.
*/ */
srv = objt_server(s->target); srv = objt_server(s->target);
if (unlikely(sc_ep_test(csf, SE_FL_ERROR))) { if (unlikely(sc_ep_test(scf, SE_FL_ERROR))) {
if (cs_state_in(csf->state, CS_SB_EST|CS_SB_DIS)) { if (cs_state_in(scf->state, CS_SB_EST|CS_SB_DIS)) {
cs_shutr(csf); cs_shutr(scf);
cs_shutw(csf); cs_shutw(scf);
cs_report_error(csf); cs_report_error(scf);
if (!(req->analysers) && !(res->analysers)) { if (!(req->analysers) && !(res->analysers)) {
_HA_ATOMIC_INC(&s->be->be_counters.cli_aborts); _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
_HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts); _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
@ -1774,11 +1774,11 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
} }
} }
if (unlikely(sc_ep_test(csb, SE_FL_ERROR))) { if (unlikely(sc_ep_test(scb, SE_FL_ERROR))) {
if (cs_state_in(csb->state, CS_SB_EST|CS_SB_DIS)) { if (cs_state_in(scb->state, CS_SB_EST|CS_SB_DIS)) {
cs_shutr(csb); cs_shutr(scb);
cs_shutw(csb); cs_shutw(scb);
cs_report_error(csb); cs_report_error(scb);
_HA_ATOMIC_INC(&s->be->be_counters.failed_resp); _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
if (srv) if (srv)
_HA_ATOMIC_INC(&srv->counters.failed_resp); _HA_ATOMIC_INC(&srv->counters.failed_resp);
@ -1798,18 +1798,18 @@ 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(csb->state, CS_SB_CON|CS_SB_RDY)) { if (cs_state_in(scb->state, CS_SB_CON|CS_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 (csb->state == CS_ST_RDY) if (scb->state == CS_ST_RDY)
back_handle_st_rdy(s); back_handle_st_rdy(s);
else if (s->csb->state == CS_ST_CON) else if (s->scb->state == CS_ST_CON)
back_handle_st_con(s); back_handle_st_con(s);
if (csb->state == CS_ST_CER) if (scb->state == CS_ST_CER)
back_handle_st_cer(s); back_handle_st_cer(s);
else if (csb->state == CS_ST_EST) else if (scb->state == CS_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 CS_ST_CON (still in progress), CS_ST_EST
@ -1818,17 +1818,17 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
*/ */
} }
rq_prod_last = csf->state; rq_prod_last = scf->state;
rq_cons_last = csb->state; rq_cons_last = scb->state;
rp_cons_last = csf->state; rp_cons_last = scf->state;
rp_prod_last = csb->state; rp_prod_last = scb->state;
/* Check for connection closure */ /* Check for connection closure */
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(csf->state == CS_ST_DIS)) { if (unlikely(scf->state == CS_ST_DIS)) {
csf->state = CS_ST_CLO; scf->state = CS_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.
@ -1838,8 +1838,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
(global.mode & MODE_VERBOSE)))) { (global.mode & MODE_VERBOSE)))) {
chunk_printf(&trash, "%08x:%s.clicls[%04x:%04x]\n", chunk_printf(&trash, "%08x:%s.clicls[%04x:%04x]\n",
s->uniq_id, s->be->id, s->uniq_id, s->be->id,
(unsigned short)conn_fd(cs_conn(csf)), (unsigned short)conn_fd(cs_conn(scf)),
(unsigned short)conn_fd(cs_conn(csb))); (unsigned short)conn_fd(cs_conn(scb)));
DISGUISE(write(1, trash.area, trash.data)); DISGUISE(write(1, trash.area, trash.data));
} }
} }
@ -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(csb->state == CS_ST_DIS)) { if (unlikely(scb->state == CS_ST_DIS)) {
csb->state = CS_ST_CLO; scb->state = CS_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) {
@ -1869,8 +1869,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (s->prev_conn_state == CS_ST_EST) { if (s->prev_conn_state == CS_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(csf)), (unsigned short)conn_fd(cs_conn(scf)),
(unsigned short)conn_fd(cs_conn(csb))); (unsigned short)conn_fd(cs_conn(scb)));
DISGUISE(write(1, trash.area, trash.data)); DISGUISE(write(1, trash.area, trash.data));
} }
} }
@ -1886,12 +1886,12 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (((req->flags & ~rqf_last) & CF_MASK_ANALYSER) || if (((req->flags & ~rqf_last) & CF_MASK_ANALYSER) ||
((req->flags ^ rqf_last) & CF_MASK_STATIC) || ((req->flags ^ rqf_last) & CF_MASK_STATIC) ||
(req->analysers && (req->flags & CF_SHUTW)) || (req->analysers && (req->flags & CF_SHUTW)) ||
csf->state != rq_prod_last || scf->state != rq_prod_last ||
csb->state != rq_cons_last || scb->state != rq_cons_last ||
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(csf->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) { if (cs_state_in(scf->state, CS_SB_EST|CS_SB_DIS|CS_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;
@ -1966,8 +1966,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
} }
} }
rq_prod_last = csf->state; rq_prod_last = scf->state;
rq_cons_last = csb->state; rq_cons_last = scb->state;
req->flags &= ~CF_WAKE_ONCE; req->flags &= ~CF_WAKE_ONCE;
rqf_last = req->flags; rqf_last = req->flags;
@ -1987,12 +1987,12 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (((res->flags & ~rpf_last) & CF_MASK_ANALYSER) || if (((res->flags & ~rpf_last) & CF_MASK_ANALYSER) ||
(res->flags ^ rpf_last) & CF_MASK_STATIC || (res->flags ^ rpf_last) & CF_MASK_STATIC ||
(res->analysers && (res->flags & CF_SHUTW)) || (res->analysers && (res->flags & CF_SHUTW)) ||
csf->state != rp_cons_last || scf->state != rp_cons_last ||
csb->state != rp_prod_last || scb->state != rp_prod_last ||
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(csb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) { if (cs_state_in(scb->state, CS_SB_EST|CS_SB_DIS|CS_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;
@ -2035,8 +2035,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
} }
} }
rp_cons_last = csf->state; rp_cons_last = scf->state;
rp_prod_last = csb->state; rp_prod_last = scb->state;
res->flags &= ~CF_WAKE_ONCE; res->flags &= ~CF_WAKE_ONCE;
rpf_last = res->flags; rpf_last = res->flags;
@ -2108,8 +2108,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
* the backend stream connector is in the CS_ST_INI * the backend stream connector is in the CS_ST_INI
* state. It is switched into the CS_ST_CLO state and * state. It is switched into the CS_ST_CLO state and
* the request channel is erased. */ * the request channel is erased. */
if (csb->state == CS_ST_INI) { if (scb->state == CS_ST_INI) {
s->csb->state = CS_ST_CLO; s->scb->state = CS_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(csf->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) && (cs_state_in(scf->state, CS_SB_EST|CS_SB_DIS|CS_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
@ -2207,10 +2207,10 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (!(req->flags & (CF_KERN_SPLICING|CF_SHUTR)) && if (!(req->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
req->to_forward && req->to_forward &&
(global.tune.options & GTUNE_USE_SPLICE) && (global.tune.options & GTUNE_USE_SPLICE) &&
(cs_conn(csf) && __cs_conn(csf)->xprt && __cs_conn(csf)->xprt->rcv_pipe && (cs_conn(scf) && __cs_conn(scf)->xprt && __cs_conn(scf)->xprt->rcv_pipe &&
__cs_conn(csf)->mux && __cs_conn(csf)->mux->rcv_pipe) && __cs_conn(scf)->mux && __cs_conn(scf)->mux->rcv_pipe) &&
(cs_conn(csb) && __cs_conn(csb)->xprt && __cs_conn(csb)->xprt->snd_pipe && (cs_conn(scb) && __cs_conn(scb)->xprt && __cs_conn(scb)->xprt->snd_pipe &&
__cs_conn(csb)->mux && __cs_conn(csb)->mux->snd_pipe) && __cs_conn(scb)->mux && __cs_conn(scb)->mux->snd_pipe) &&
(pipes_used < global.maxpipes) && (pipes_used < global.maxpipes) &&
(((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) || (((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
(((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) && (((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
@ -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 (csb->state == CS_ST_INI) { if (scb->state == CS_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.
*/ */
csb->state = CS_ST_REQ; /* new connection requested */ scb->state = CS_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->csb->state = CS_ST_CLO; /* shutw+ini = abort */ s->scb->state = CS_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(csb->state, CS_SB_REQ|CS_SB_QUE|CS_SB_TAR|CS_SB_ASS)) { if (cs_state_in(scb->state, CS_SB_REQ|CS_SB_QUE|CS_SB_TAR|CS_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,30 +2264,30 @@ 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 (csb->state != CS_ST_REQ) if (scb->state != CS_ST_REQ)
back_try_conn_req(s); back_try_conn_req(s);
if (csb->state == CS_ST_REQ) if (scb->state == CS_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 (csb->state == CS_ST_RDY) if (scb->state == CS_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(csb->state == CS_ST_EST)) if (unlikely(scb->state == CS_ST_EST))
back_establish(s); back_establish(s);
srv = objt_server(s->target); srv = objt_server(s->target);
if (csb->state == CS_ST_ASS && srv && srv->rdr_len && (s->flags & SF_REDIRECTABLE)) if (scb->state == CS_ST_ASS && srv && srv->rdr_len && (s->flags & SF_REDIRECTABLE))
http_perform_server_redirect(s, csb); http_perform_server_redirect(s, scb);
} while (csb->state == CS_ST_ASS); } while (scb->state == CS_ST_ASS);
} }
/* Let's see if we can send the pending request now */ /* Let's see if we can send the pending request now */
cs_conn_sync_send(csb); cs_conn_sync_send(scb);
/* /*
* Now forward all shutdown requests between both sides of the request buffer * Now forward all shutdown requests between both sides of the request buffer
@ -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) &&
(csb->state != CS_ST_CON || (s->be->options & PR_O_ABRT_CLOSE)))) { (scb->state != CS_ST_CON || (s->be->options & PR_O_ABRT_CLOSE)))) {
channel_shutw_now(req); channel_shutw_now(req);
} }
@ -2309,8 +2309,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW && if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
channel_is_empty(req))) { channel_is_empty(req))) {
if (req->flags & CF_READ_ERROR) if (req->flags & CF_READ_ERROR)
csb->flags |= CS_FL_NOLINGER; scb->flags |= CS_FL_NOLINGER;
cs_shutw(csb); cs_shutw(scb);
} }
/* shutdown(write) done on server side, we must stop the client too */ /* shutdown(write) done on server side, we must stop the client too */
@ -2320,16 +2320,16 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
/* shutdown(read) pending */ /* shutdown(read) pending */
if (unlikely((req->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) { if (unlikely((req->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
if (csf->flags & CS_FL_NOHALF) if (scf->flags & CS_FL_NOHALF)
csf->flags |= CS_FL_NOLINGER; scf->flags |= CS_FL_NOLINGER;
cs_shutr(csf); cs_shutr(scf);
} }
/* 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 (csf->state == CS_ST_DIS || if (scf->state == CS_ST_DIS ||
cs_state_in(csb->state, CS_SB_RDY|CS_SB_DIS) || cs_state_in(scb->state, CS_SB_RDY|CS_SB_DIS) ||
(sc_ep_test(csf, SE_FL_ERROR) && csf->state != CS_ST_CLO) || (sc_ep_test(scf, SE_FL_ERROR) && scf->state != CS_ST_CLO) ||
(sc_ep_test(csb, SE_FL_ERROR) && csb->state != CS_ST_CLO)) (sc_ep_test(scb, SE_FL_ERROR) && scb->state != CS_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(csb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO) && cs_state_in(scb->state, CS_SB_EST|CS_SB_DIS|CS_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
@ -2401,10 +2401,10 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (!(res->flags & (CF_KERN_SPLICING|CF_SHUTR)) && if (!(res->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
res->to_forward && res->to_forward &&
(global.tune.options & GTUNE_USE_SPLICE) && (global.tune.options & GTUNE_USE_SPLICE) &&
(cs_conn(csf) && __cs_conn(csf)->xprt && __cs_conn(csf)->xprt->snd_pipe && (cs_conn(scf) && __cs_conn(scf)->xprt && __cs_conn(scf)->xprt->snd_pipe &&
__cs_conn(csf)->mux && __cs_conn(csf)->mux->snd_pipe) && __cs_conn(scf)->mux && __cs_conn(scf)->mux->snd_pipe) &&
(cs_conn(csb) && __cs_conn(csb)->xprt && __cs_conn(csb)->xprt->rcv_pipe && (cs_conn(scb) && __cs_conn(scb)->xprt && __cs_conn(scb)->xprt->rcv_pipe &&
__cs_conn(csb)->mux && __cs_conn(csb)->mux->rcv_pipe) && __cs_conn(scb)->mux && __cs_conn(scb)->mux->rcv_pipe) &&
(pipes_used < global.maxpipes) && (pipes_used < global.maxpipes) &&
(((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) || (((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
(((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) && (((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
@ -2416,7 +2416,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
rpf_last = res->flags; rpf_last = res->flags;
/* Let's see if we can send the pending response now */ /* Let's see if we can send the pending response now */
cs_conn_sync_send(csf); cs_conn_sync_send(scf);
/* /*
* Now forward all shutdown requests between both sides of the buffer * Now forward all shutdown requests between both sides of the buffer
@ -2435,7 +2435,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
/* shutdown(write) pending */ /* shutdown(write) pending */
if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW && if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
channel_is_empty(res))) { channel_is_empty(res))) {
cs_shutw(csf); cs_shutw(scf);
} }
/* shutdown(write) done on the client side, we must stop the server too */ /* shutdown(write) done on the client side, we must stop the server too */
@ -2445,15 +2445,15 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
/* shutdown(read) pending */ /* shutdown(read) pending */
if (unlikely((res->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) { if (unlikely((res->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
if (csb->flags & CS_FL_NOHALF) if (scb->flags & CS_FL_NOHALF)
csb->flags |= CS_FL_NOLINGER; scb->flags |= CS_FL_NOLINGER;
cs_shutr(csb); cs_shutr(scb);
} }
if (csf->state == CS_ST_DIS || if (scf->state == CS_ST_DIS ||
cs_state_in(csb->state, CS_SB_RDY|CS_SB_DIS) || cs_state_in(scb->state, CS_SB_RDY|CS_SB_DIS) ||
(sc_ep_test(csf, SE_FL_ERROR) && csf->state != CS_ST_CLO) || (sc_ep_test(scf, SE_FL_ERROR) && scf->state != CS_ST_CLO) ||
(sc_ep_test(csb, SE_FL_ERROR) && csb->state != CS_ST_CLO)) (sc_ep_test(scb, SE_FL_ERROR) && scb->state != CS_ST_CLO))
goto resync_stconns; goto resync_stconns;
if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER) if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER)
@ -2466,10 +2466,10 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
goto resync_request; goto resync_request;
/* we're interested in getting wakeups again */ /* we're interested in getting wakeups again */
csf->flags &= ~CS_FL_DONT_WAKE; scf->flags &= ~CS_FL_DONT_WAKE;
csb->flags &= ~CS_FL_DONT_WAKE; scb->flags &= ~CS_FL_DONT_WAKE;
if (likely((csf->state != CS_ST_CLO) || !cs_state_in(csb->state, CS_SB_INI|CS_SB_CLO) || if (likely((scf->state != CS_ST_CLO) || !cs_state_in(scb->state, CS_SB_INI|CS_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);
@ -2527,8 +2527,8 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
(!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) { (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) {
chunk_printf(&trash, "%08x:%s.closed[%04x:%04x]\n", chunk_printf(&trash, "%08x:%s.closed[%04x:%04x]\n",
s->uniq_id, s->be->id, s->uniq_id, s->be->id,
(unsigned short)conn_fd(cs_conn(csf)), (unsigned short)conn_fd(cs_conn(scf)),
(unsigned short)conn_fd(cs_conn(csb))); (unsigned short)conn_fd(cs_conn(scb)));
DISGUISE(write(1, trash.area, trash.data)); DISGUISE(write(1, trash.area, trash.data));
} }
@ -2730,7 +2730,7 @@ void stream_shutdown(struct stream *stream, int why)
*/ */
void stream_dump(struct buffer *buf, const struct stream *s, const char *pfx, char eol) void stream_dump(struct buffer *buf, const struct stream *s, const char *pfx, char eol)
{ {
const struct stconn *csf, *csb; const struct stconn *scf, *scb;
const struct connection *cof, *cob; const struct connection *cof, *cob;
const struct appctx *acf, *acb; const struct appctx *acf, *acb;
const struct server *srv; const struct server *srv;
@ -2753,17 +2753,17 @@ void stream_dump(struct buffer *buf, const struct stream *s, const char *pfx, ch
req = &s->req; req = &s->req;
res = &s->res; res = &s->res;
csf = s->csf; scf = s->scf;
cof = cs_conn(csf); cof = cs_conn(scf);
acf = cs_appctx(csf); acf = cs_appctx(scf);
if (cof && cof->src && addr_to_str(cof->src, pn, sizeof(pn)) >= 0) if (cof && cof->src && addr_to_str(cof->src, pn, sizeof(pn)) >= 0)
src = pn; src = pn;
else if (acf) else if (acf)
src = acf->applet->name; src = acf->applet->name;
csb = s->csb; scb = s->scb;
cob = cs_conn(csb); cob = cs_conn(scb);
acb = cs_appctx(csb); acb = cs_appctx(scb);
srv = objt_server(s->target); srv = objt_server(s->target);
if (srv) if (srv)
dst = srv->id; dst = srv->id;
@ -2774,7 +2774,7 @@ void stream_dump(struct buffer *buf, const struct stream *s, const char *pfx, ch
"%sstrm=%p,%x src=%s fe=%s be=%s dst=%s%c" "%sstrm=%p,%x src=%s fe=%s be=%s dst=%s%c"
"%stxn=%p,%x txn.req=%s,%x txn.rsp=%s,%x%c" "%stxn=%p,%x txn.req=%s,%x txn.rsp=%s,%x%c"
"%srqf=%x rqa=%x rpf=%x rpa=%x%c" "%srqf=%x rqa=%x rpf=%x rpa=%x%c"
"%scsf=%p,%s,%x csb=%p,%s,%x%c" "%sscf=%p,%s,%x scb=%p,%s,%x%c"
"%saf=%p,%u sab=%p,%u%c" "%saf=%p,%u sab=%p,%u%c"
"%scof=%p,%x:%s(%p)/%s(%p)/%s(%d)%c" "%scof=%p,%x:%s(%p)/%s(%p)/%s(%d)%c"
"%scob=%p,%x:%s(%p)/%s(%p)/%s(%d)%c" "%scob=%p,%x:%s(%p)/%s(%p)/%s(%d)%c"
@ -2784,7 +2784,7 @@ void stream_dump(struct buffer *buf, const struct stream *s, const char *pfx, ch
(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->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, (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, req->flags, req->analysers, res->flags, res->analysers, eol,
pfx, csf, cs_state_str(csf->state), csf->flags, csb, cs_state_str(csb->state), csb->flags, eol, pfx, scf, cs_state_str(scf->state), scf->flags, scb, cs_state_str(scb->state), scb->flags, eol,
pfx, acf, acf ? acf->st0 : 0, acb, acb ? acb->st0 : 0, 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), 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, cof ? cof->xprt_ctx : 0, conn_get_ctrl_name(cof), conn_fd(cof), eol,
@ -3154,7 +3154,7 @@ static int stats_dump_full_strm_to_buffer(struct stconn *cs, struct stream *strm
{ {
struct appctx *appctx = __cs_appctx(cs); struct appctx *appctx = __cs_appctx(cs);
struct show_sess_ctx *ctx = appctx->svcctx; struct show_sess_ctx *ctx = appctx->svcctx;
struct stconn *csf, *csb; struct stconn *scf, *scb;
struct tm tm; struct tm tm;
extern const char *monthname[12]; extern const char *monthname[12];
char pn[INET6_ADDRSTRLEN]; char pn[INET6_ADDRSTRLEN];
@ -3242,7 +3242,7 @@ static int stats_dump_full_strm_to_buffer(struct stconn *cs, struct stream *strm
else else
chunk_appendf(&trash, " backend=<NONE> (id=-1 mode=-)"); chunk_appendf(&trash, " backend=<NONE> (id=-1 mode=-)");
conn = cs_conn(strm->csb); conn = cs_conn(strm->scb);
switch (conn && conn_get_src(conn) ? addr_to_str(conn->src, pn, sizeof(pn)) : AF_UNSPEC) { switch (conn && conn_get_src(conn) ? addr_to_str(conn->src, pn, sizeof(pn)) : AF_UNSPEC) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
@ -3304,20 +3304,20 @@ static int stats_dump_full_strm_to_buffer(struct stconn *cs, struct stream *strm
h1_msg_state_str(strm->txn->req.msg_state), h1_msg_state_str(strm->txn->rsp.msg_state), h1_msg_state_str(strm->txn->req.msg_state), h1_msg_state_str(strm->txn->rsp.msg_state),
strm->txn->req.flags, strm->txn->rsp.flags); strm->txn->req.flags, strm->txn->rsp.flags);
csf = strm->csf; scf = strm->scf;
chunk_appendf(&trash, " csf=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n", chunk_appendf(&trash, " scf=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
csf, csf->flags, cs_state_str(csf->state), scf, scf->flags, cs_state_str(scf->state),
(sc_ep_test(csf, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(csf, SE_FL_T_APPLET) ? "APPCTX" : "NONE")), (sc_ep_test(scf, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(scf, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
csf->sedesc->se, sc_ep_get(csf), csf->wait_event.events); scf->sedesc->se, sc_ep_get(scf), scf->wait_event.events);
if ((conn = cs_conn(csf)) != NULL) { if ((conn = cs_conn(scf)) != NULL) {
chunk_appendf(&trash, chunk_appendf(&trash,
" co0=%p ctrl=%s xprt=%s mux=%s data=%s target=%s:%p\n", " co0=%p ctrl=%s xprt=%s mux=%s data=%s target=%s:%p\n",
conn, conn,
conn_get_ctrl_name(conn), conn_get_ctrl_name(conn),
conn_get_xprt_name(conn), conn_get_xprt_name(conn),
conn_get_mux_name(conn), conn_get_mux_name(conn),
cs_get_data_name(csf), cs_get_data_name(scf),
obj_type_name(conn->target), obj_type_name(conn->target),
obj_base_ptr(conn->target)); obj_base_ptr(conn->target));
@ -3330,7 +3330,7 @@ static int stats_dump_full_strm_to_buffer(struct stconn *cs, struct stream *strm
conn_fd(conn) >= 0 ? fdtab[conn->handle.fd].thread_mask: 0); conn_fd(conn) >= 0 ? fdtab[conn->handle.fd].thread_mask: 0);
} }
else if ((tmpctx = cs_appctx(csf)) != NULL) { else if ((tmpctx = cs_appctx(scf)) != NULL) {
chunk_appendf(&trash, chunk_appendf(&trash,
" app0=%p st0=%d st1=%d st2=%d applet=%s tmask=0x%lx nice=%d calls=%u rate=%u cpu=%llu lat=%llu\n", " app0=%p st0=%d st1=%d st2=%d applet=%s tmask=0x%lx nice=%d calls=%u rate=%u cpu=%llu lat=%llu\n",
tmpctx, tmpctx,
@ -3343,20 +3343,20 @@ static int stats_dump_full_strm_to_buffer(struct stconn *cs, struct stream *strm
(unsigned long long)tmpctx->t->cpu_time, (unsigned long long)tmpctx->t->lat_time); (unsigned long long)tmpctx->t->cpu_time, (unsigned long long)tmpctx->t->lat_time);
} }
csb = strm->csb; scb = strm->scb;
chunk_appendf(&trash, " csb=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n", chunk_appendf(&trash, " scb=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
csb, csb->flags, cs_state_str(csb->state), scb, scb->flags, cs_state_str(scb->state),
(sc_ep_test(csb, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(csb, SE_FL_T_APPLET) ? "APPCTX" : "NONE")), (sc_ep_test(scb, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(scb, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
csb->sedesc->se, sc_ep_get(csb), csb->wait_event.events); scb->sedesc->se, sc_ep_get(scb), scb->wait_event.events);
if ((conn = cs_conn(csb)) != NULL) { if ((conn = cs_conn(scb)) != NULL) {
chunk_appendf(&trash, chunk_appendf(&trash,
" co1=%p ctrl=%s xprt=%s mux=%s data=%s target=%s:%p\n", " co1=%p ctrl=%s xprt=%s mux=%s data=%s target=%s:%p\n",
conn, conn,
conn_get_ctrl_name(conn), conn_get_ctrl_name(conn),
conn_get_xprt_name(conn), conn_get_xprt_name(conn),
conn_get_mux_name(conn), conn_get_mux_name(conn),
cs_get_data_name(csb), cs_get_data_name(scb),
obj_type_name(conn->target), obj_type_name(conn->target),
obj_base_ptr(conn->target)); obj_base_ptr(conn->target));
@ -3369,7 +3369,7 @@ static int stats_dump_full_strm_to_buffer(struct stconn *cs, struct stream *strm
conn_fd(conn) >= 0 ? fdtab[conn->handle.fd].thread_mask: 0); conn_fd(conn) >= 0 ? fdtab[conn->handle.fd].thread_mask: 0);
} }
else if ((tmpctx = cs_appctx(csb)) != NULL) { else if ((tmpctx = cs_appctx(scb)) != NULL) {
chunk_appendf(&trash, chunk_appendf(&trash,
" app1=%p st0=%d st1=%d st2=%d applet=%s tmask=0x%lx nice=%d calls=%u rate=%u cpu=%llu lat=%llu\n", " app1=%p st0=%d st1=%d st2=%d applet=%s tmask=0x%lx nice=%d calls=%u rate=%u cpu=%llu lat=%llu\n",
tmpctx, tmpctx,
@ -3679,18 +3679,18 @@ static int cli_io_handler_dump_sess(struct appctx *appctx)
human_time(TICKS_TO_MS(curr_strm->res.analyse_exp - now_ms), human_time(TICKS_TO_MS(curr_strm->res.analyse_exp - now_ms),
TICKS_TO_MS(1000)) : ""); TICKS_TO_MS(1000)) : "");
conn = cs_conn(curr_strm->csf); conn = cs_conn(curr_strm->scf);
chunk_appendf(&trash, chunk_appendf(&trash,
" csf=[%d,%1xh,fd=%d]", " scf=[%d,%1xh,fd=%d]",
curr_strm->csf->state, curr_strm->scf->state,
curr_strm->csf->flags, curr_strm->scf->flags,
conn_fd(conn)); conn_fd(conn));
conn = cs_conn(curr_strm->csb); conn = cs_conn(curr_strm->scb);
chunk_appendf(&trash, chunk_appendf(&trash,
" csb=[%d,%1xh,fd=%d]", " scb=[%d,%1xh,fd=%d]",
curr_strm->csb->state, curr_strm->scb->state,
curr_strm->csb->flags, curr_strm->scb->flags,
conn_fd(conn)); conn_fd(conn));
chunk_appendf(&trash, chunk_appendf(&trash,

18
src/tcp_act.c
View File

@ -67,9 +67,9 @@ static enum act_return tcp_action_req_set_src(struct act_rule *rule, struct prox
case ACT_F_TCP_REQ_CNT: case ACT_F_TCP_REQ_CNT:
case ACT_F_HTTP_REQ: case ACT_F_HTTP_REQ:
if (!cs_get_src(s->csf)) if (!cs_get_src(s->scf))
goto end; goto end;
src = s->csf->src; src = s->scf->src;
break; break;
default: default:
@ -123,9 +123,9 @@ static enum act_return tcp_action_req_set_dst(struct act_rule *rule, struct prox
case ACT_F_TCP_REQ_CNT: case ACT_F_TCP_REQ_CNT:
case ACT_F_HTTP_REQ: case ACT_F_HTTP_REQ:
if (!cs_get_dst(s->csf)) if (!cs_get_dst(s->scf))
goto end; goto end;
dst = s->csf->dst; dst = s->scf->dst;
break; break;
default: default:
@ -180,9 +180,9 @@ static enum act_return tcp_action_req_set_src_port(struct act_rule *rule, struct
case ACT_F_TCP_REQ_CNT: case ACT_F_TCP_REQ_CNT:
case ACT_F_HTTP_REQ: case ACT_F_HTTP_REQ:
if (!cs_get_src(s->csf)) if (!cs_get_src(s->scf))
goto end; goto end;
src = s->csf->src; src = s->scf->src;
break; break;
default: default:
@ -235,9 +235,9 @@ static enum act_return tcp_action_req_set_dst_port(struct act_rule *rule, struct
case ACT_F_TCP_REQ_CNT: case ACT_F_TCP_REQ_CNT:
case ACT_F_HTTP_REQ: case ACT_F_HTTP_REQ:
if (!cs_get_dst(s->csf)) if (!cs_get_dst(s->scf))
goto end; goto end;
dst = s->csf->dst; dst = s->scf->dst;
break; break;
default: default:
@ -287,7 +287,7 @@ static enum act_return tcp_exec_action_silent_drop(struct act_rule *rule, struct
* is present, returning with ERR will cause lingering to be disabled. * is present, returning with ERR will cause lingering to be disabled.
*/ */
if (strm) if (strm)
strm->csf->flags |= CS_FL_NOLINGER; strm->scf->flags |= CS_FL_NOLINGER;
if (conn->flags & CO_FL_FDLESS) if (conn->flags & CO_FL_FDLESS)
goto out; goto out;

22
src/tcp_sample.c
View File

@ -53,7 +53,7 @@ smp_fetch_src(const struct arg *args, struct sample *smp, const char *kw, void *
if (kw[0] == 'b') { /* bc_src */ if (kw[0] == 'b') { /* bc_src */
struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK) struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
? cs_conn(__objt_check(smp->sess->origin)->cs) ? cs_conn(__objt_check(smp->sess->origin)->cs)
: (smp->strm ? cs_conn(smp->strm->csb): NULL)); : (smp->strm ? cs_conn(smp->strm->scb): NULL));
if (conn && conn_get_src(conn)) if (conn && conn_get_src(conn))
src = conn_src(conn); src = conn_src(conn);
} }
@ -64,7 +64,7 @@ smp_fetch_src(const struct arg *args, struct sample *smp, const char *kw, void *
src = conn_src(conn); src = conn_src(conn);
} }
else /* src */ else /* src */
src = (smp->strm ? cs_src(smp->strm->csf) : sess_src(smp->sess)); src = (smp->strm ? cs_src(smp->strm->scf) : sess_src(smp->sess));
if (!src) if (!src)
return 0; return 0;
@ -97,7 +97,7 @@ smp_fetch_sport(const struct arg *args, struct sample *smp, const char *kw, void
if (kw[0] == 'b') { /* bc_src_port */ if (kw[0] == 'b') { /* bc_src_port */
struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK) struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
? cs_conn(__objt_check(smp->sess->origin)->cs) ? cs_conn(__objt_check(smp->sess->origin)->cs)
: (smp->strm ? cs_conn(smp->strm->csb): NULL)); : (smp->strm ? cs_conn(smp->strm->scb): NULL));
if (conn && conn_get_src(conn)) if (conn && conn_get_src(conn))
src = conn_src(conn); src = conn_src(conn);
} }
@ -108,7 +108,7 @@ smp_fetch_sport(const struct arg *args, struct sample *smp, const char *kw, void
src = conn_src(conn); src = conn_src(conn);
} }
else /* src_port */ else /* src_port */
src = (smp->strm ? cs_src(smp->strm->csf) : sess_src(smp->sess)); src = (smp->strm ? cs_src(smp->strm->scf) : sess_src(smp->sess));
if (!src) if (!src)
return 0; return 0;
@ -132,7 +132,7 @@ smp_fetch_dst(const struct arg *args, struct sample *smp, const char *kw, void *
if (kw[0] == 'b') { /* bc_dst */ if (kw[0] == 'b') { /* bc_dst */
struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK) struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
? cs_conn(__objt_check(smp->sess->origin)->cs) ? cs_conn(__objt_check(smp->sess->origin)->cs)
: (smp->strm ? cs_conn(smp->strm->csb): NULL)); : (smp->strm ? cs_conn(smp->strm->scb): NULL));
if (conn && conn_get_dst(conn)) if (conn && conn_get_dst(conn))
dst = conn_dst(conn); dst = conn_dst(conn);
} }
@ -143,7 +143,7 @@ smp_fetch_dst(const struct arg *args, struct sample *smp, const char *kw, void *
dst = conn_dst(conn); dst = conn_dst(conn);
} }
else /* dst */ else /* dst */
dst = (smp->strm ? cs_dst(smp->strm->csf) : sess_dst(smp->sess)); dst = (smp->strm ? cs_dst(smp->strm->scf) : sess_dst(smp->sess));
if (!dst) if (!dst)
return 0; return 0;
@ -180,7 +180,7 @@ int smp_fetch_dst_is_local(const struct arg *args, struct sample *smp, const cha
dst = conn_dst(conn); dst = conn_dst(conn);
} }
else /* dst_is_local */ else /* dst_is_local */
dst = (smp->strm ? cs_dst(smp->strm->csf) : sess_dst(smp->sess)); dst = (smp->strm ? cs_dst(smp->strm->scf) : sess_dst(smp->sess));
if (!dst) if (!dst)
return 0; return 0;
@ -206,7 +206,7 @@ int smp_fetch_src_is_local(const struct arg *args, struct sample *smp, const cha
src = conn_src(conn); src = conn_src(conn);
} }
else /* src_is_local */ else /* src_is_local */
src = (smp->strm ? cs_src(smp->strm->csf) : sess_src(smp->sess)); src = (smp->strm ? cs_src(smp->strm->scf) : sess_src(smp->sess));
if (!src) if (!src)
return 0; return 0;
@ -228,7 +228,7 @@ smp_fetch_dport(const struct arg *args, struct sample *smp, const char *kw, void
if (kw[0] == 'b') { /* bc_dst_port */ if (kw[0] == 'b') { /* bc_dst_port */
struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK) struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
? cs_conn(__objt_check(smp->sess->origin)->cs) ? cs_conn(__objt_check(smp->sess->origin)->cs)
: (smp->strm ? cs_conn(smp->strm->csb): NULL)); : (smp->strm ? cs_conn(smp->strm->scb): NULL));
if (conn && conn_get_dst(conn)) if (conn && conn_get_dst(conn))
dst = conn_dst(conn); dst = conn_dst(conn);
} }
@ -239,7 +239,7 @@ smp_fetch_dport(const struct arg *args, struct sample *smp, const char *kw, void
dst = conn_dst(conn); dst = conn_dst(conn);
} }
else /* dst_port */ else /* dst_port */
dst = (smp->strm ? cs_dst(smp->strm->csf) : sess_dst(smp->sess)); dst = (smp->strm ? cs_dst(smp->strm->scf) : sess_dst(smp->sess));
if (!dst) if (!dst)
return 0; return 0;
@ -325,7 +325,7 @@ static inline int get_tcp_info(const struct arg *args, struct sample *smp,
* object can be other thing than a connection. For example, * object can be other thing than a connection. For example,
* it be a appctx. * it be a appctx.
*/ */
conn = (dir == 0 ? cs_conn(smp->strm->csf) : cs_conn(smp->strm->csb)); conn = (dir == 0 ? cs_conn(smp->strm->scf) : cs_conn(smp->strm->scb));
if (!conn) if (!conn)
return 0; return 0;