const struct http_txn *txn = a2;
const struct http_msg *msg = a3;
struct task *task;
- const struct stream_interface *si_f, *si_b;
const struct channel *req, *res;
struct htx *htx;
return;
task = s->task;
- si_f = cs_si(s->csf);
- si_b = cs_si(s->csb);
req = &s->req;
res = &s->res;
htx = (msg ? htxbuf(&msg->chn->buf) : NULL);
task, s, s->flags, s->conn_err_type, txn->flags, txn->req.flags, txn->rsp.flags, txn->status);
}
else {
- chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x,0x%x) si_f=(%p,0x%08x) si_b=(%p,0x%08x) retries=%d",
- task, s, s->flags, s->conn_err_type, si_f, si_f->flags, si_b, si_b->flags, s->conn_retries);
+ chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x,0x%x) csf=(%p,%d,0x%08x) csb=(%p,%d,0x%08x) retries=%d",
+ task, s, s->flags, s->conn_err_type,
+ s->csf, s->csf->state, s->csf->flags,
+ s->csb, s->csb->state, s->csb->flags,
+ s->conn_retries);
}
if (src->verbosity == STRM_VERB_MINIMAL)
if (likely(sess->fe->options2 & PR_O2_INDEPSTR))
s->csf->flags |= CS_FL_INDEP_STR;
- cs_si(s->csb)->flags = SI_FL_ISBACK;
s->csb->hcto = TICK_ETERNITY;
if (likely(sess->fe->options2 & PR_O2_INDEPSTR))
s->csb->flags |= CS_FL_INDEP_STR;
out_fail_accept:
flt_stream_release(s, 0);
LIST_DELETE(&s->list);
- out_fail_attach_csb:
- si_free(cs_si(s->csf));
out_fail_attach_csf:
cs_free(s->csb);
out_fail_alloc_csb:
struct session *sess = strm_sess(s);
struct proxy *fe = sess->fe;
struct bref *bref, *back;
- /* struct conn_stream *cli_cs = objt_cs(s->si[0].end); */
int must_free_sess;
int i;
static void back_establish(struct stream *s)
{
struct connection *conn = cs_conn(s->csb);
- struct stream_interface *si = cs_si(s->csb);
struct channel *req = &s->req;
struct channel *rep = &s->res;
* delayed recv here to give a chance to the data to flow back
* by the time we process other tasks.
*/
- cs_chk_rcv(si->cs);
+ cs_chk_rcv(s->csb);
}
req->wex = TICK_ETERNITY;
/* If we managed to get the whole response, and we don't have anything
* silently destroyed. The new mux will create new
* streams.
*/
- /* FIXME: must be tested */
- /* si_release_endpoint(cs_si(s->csf)); */
s->logs.logwait = 0;
s->logs.level = 0;
channel_abort(&s->req);
unsigned int rp_cons_last, rp_prod_last;
unsigned int req_ana_back;
struct channel *req, *res;
- struct stream_interface *si_f, *si_b;
+ struct conn_stream *csf, *csb;
unsigned int rate;
DBG_TRACE_ENTER(STRM_EV_STRM_PROC, s);
req = &s->req;
res = &s->res;
- si_f = cs_si(s->csf);
- si_b = cs_si(s->csb);
+ csf = s->csf;
+ csb = s->csb;
/* First, attempt to receive pending data from I/O layers */
- cs_conn_sync_recv(s->csf);
- cs_conn_sync_recv(s->csb);
+ cs_conn_sync_recv(csf);
+ cs_conn_sync_recv(csb);
/* 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
rpf_last = res->flags & ~CF_MASK_ANALYSER;
/* we don't want the conn-stream functions to recursively wake us up */
- s->csf->flags |= CS_FL_DONT_WAKE;
- s->csb->flags |= CS_FL_DONT_WAKE;
+ csf->flags |= CS_FL_DONT_WAKE;
+ csb->flags |= CS_FL_DONT_WAKE;
/* update pending events */
s->pending_events |= (state & TASK_WOKEN_ANY);
channel_check_timeouts(req);
if (unlikely((req->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
- s->csb->flags |= CS_FL_NOLINGER;
- cs_shutw(s->csb);
+ csb->flags |= CS_FL_NOLINGER;
+ cs_shutw(csb);
}
if (unlikely((req->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
- if (s->csf->flags & CS_FL_NOHALF)
- s->csf->flags |= CS_FL_NOLINGER;
- cs_shutr(s->csf);
+ if (csf->flags & CS_FL_NOHALF)
+ csf->flags |= CS_FL_NOLINGER;
+ cs_shutr(csf);
}
channel_check_timeouts(res);
if (unlikely((res->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
- s->csf->flags |= CS_FL_NOLINGER;
- cs_shutw(s->csf);
+ csf->flags |= CS_FL_NOLINGER;
+ cs_shutw(csf);
}
if (unlikely((res->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
- if (s->csb->flags & CS_FL_NOHALF)
- s->csb->flags |= CS_FL_NOLINGER;
- cs_shutr(s->csb);
+ if (csb->flags & CS_FL_NOHALF)
+ csb->flags |= CS_FL_NOLINGER;
+ cs_shutr(csb);
}
if (HAS_FILTERS(s))
(CF_SHUTR|CF_READ_ACTIVITY|CF_READ_TIMEOUT|CF_SHUTW|
CF_WRITE_ACTIVITY|CF_WRITE_TIMEOUT|CF_ANA_TIMEOUT)) &&
!(s->flags & SF_CONN_EXP) &&
- !((s->csf->endp->flags | s->csb->flags) & CS_EP_ERROR) &&
+ !((csf->endp->flags | csb->flags) & CS_EP_ERROR) &&
((s->pending_events & TASK_WOKEN_ANY) == TASK_WOKEN_TIMER)) {
- s->csf->flags &= ~CS_FL_DONT_WAKE;
- s->csb->flags &= ~CS_FL_DONT_WAKE;
+ csf->flags &= ~CS_FL_DONT_WAKE;
+ csb->flags &= ~CS_FL_DONT_WAKE;
goto update_exp_and_leave;
}
}
- resync_stream_interface:
+ resync_conn_stream:
/* below we may emit error messages so we have to ensure that we have
* our buffers properly allocated. If the allocation failed, an error is
* triggered.
* connection setup code must be able to deal with any type of abort.
*/
srv = objt_server(s->target);
- if (unlikely(s->csf->endp->flags & CS_EP_ERROR)) {
- if (cs_state_in(s->csf->state, CS_SB_EST|CS_SB_DIS)) {
- cs_shutr(s->csf);
- cs_shutw(s->csf);
- cs_report_error(si_f->cs);
+ if (unlikely(csf->endp->flags & CS_EP_ERROR)) {
+ if (cs_state_in(csf->state, CS_SB_EST|CS_SB_DIS)) {
+ cs_shutr(csf);
+ cs_shutw(csf);
+ cs_report_error(csf);
if (!(req->analysers) && !(res->analysers)) {
_HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
_HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
}
}
- if (unlikely(s->csb->endp->flags & CS_EP_ERROR)) {
- if (cs_state_in(s->csb->state, CS_SB_EST|CS_SB_DIS)) {
- cs_shutr(s->csb);
- cs_shutw(s->csb);
- cs_report_error(si_b->cs);
+ if (unlikely(csb->endp->flags & CS_EP_ERROR)) {
+ if (cs_state_in(csb->state, CS_SB_EST|CS_SB_DIS)) {
+ cs_shutr(csb);
+ cs_shutw(csb);
+ cs_report_error(csb);
_HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
if (srv)
_HA_ATOMIC_INC(&srv->counters.failed_resp);
/* note: maybe we should process connection errors here ? */
}
- if (cs_state_in(s->csb->state, CS_SB_CON|CS_SB_RDY)) {
+ if (cs_state_in(csb->state, CS_SB_CON|CS_SB_RDY)) {
/* we were trying to establish a connection on the server side,
* maybe it succeeded, maybe it failed, maybe we timed out, ...
*/
- if (s->csb->state == CS_ST_RDY)
+ if (csb->state == CS_ST_RDY)
back_handle_st_rdy(s);
else if (s->csb->state == CS_ST_CON)
back_handle_st_con(s);
- if (s->csb->state == CS_ST_CER)
+ if (csb->state == CS_ST_CER)
back_handle_st_cer(s);
- else if (s->csb->state == CS_ST_EST)
+ else if (csb->state == CS_ST_EST)
back_establish(s);
/* state is now one of CS_ST_CON (still in progress), CS_ST_EST
*/
}
- rq_prod_last = s->csf->state;
- rq_cons_last = s->csb->state;
- rp_cons_last = s->csf->state;
- rp_prod_last = s->csb->state;
+ rq_prod_last = csf->state;
+ rq_cons_last = csb->state;
+ rp_cons_last = csf->state;
+ rp_prod_last = csb->state;
/* Check for connection closure */
DBG_TRACE_POINT(STRM_EV_STRM_PROC, s);
/* nothing special to be done on client side */
- if (unlikely(s->csf->state == CS_ST_DIS)) {
- s->csf->state = CS_ST_CLO;
+ if (unlikely(csf->state == CS_ST_DIS)) {
+ csf->state = CS_ST_CLO;
/* This is needed only when debugging is enabled, to indicate
* client-side close.
(global.mode & MODE_VERBOSE)))) {
chunk_printf(&trash, "%08x:%s.clicls[%04x:%04x]\n",
s->uniq_id, s->be->id,
- (unsigned short)conn_fd(cs_conn(si_f->cs)),
- (unsigned short)conn_fd(cs_conn(si_b->cs)));
+ (unsigned short)conn_fd(cs_conn(csf)),
+ (unsigned short)conn_fd(cs_conn(csb)));
DISGUISE(write(1, trash.area, trash.data));
}
}
/* When a server-side connection is released, we have to count it and
* check for pending connections on this server.
*/
- if (unlikely(s->csb->state == CS_ST_DIS)) {
- s->csb->state = CS_ST_CLO;
+ if (unlikely(csb->state == CS_ST_DIS)) {
+ csb->state = CS_ST_CLO;
srv = objt_server(s->target);
if (srv) {
if (s->flags & SF_CURR_SESS) {
if (s->prev_conn_state == CS_ST_EST) {
chunk_printf(&trash, "%08x:%s.srvcls[%04x:%04x]\n",
s->uniq_id, s->be->id,
- (unsigned short)conn_fd(__cs_conn(si_f->cs)),
- (unsigned short)conn_fd(cs_conn(si_b->cs)));
+ (unsigned short)conn_fd(cs_conn(csf)),
+ (unsigned short)conn_fd(cs_conn(csb)));
DISGUISE(write(1, trash.area, trash.data));
}
}
if (((req->flags & ~rqf_last) & CF_MASK_ANALYSER) ||
((req->flags ^ rqf_last) & CF_MASK_STATIC) ||
(req->analysers && (req->flags & CF_SHUTW)) ||
- s->csf->state != rq_prod_last ||
- s->csb->state != rq_cons_last ||
+ csf->state != rq_prod_last ||
+ csb->state != rq_cons_last ||
s->pending_events & TASK_WOKEN_MSG) {
unsigned int flags = req->flags;
- if (cs_state_in(s->csf->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) {
+ if (cs_state_in(csf->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) {
int max_loops = global.tune.maxpollevents;
unsigned int ana_list;
unsigned int ana_back;
}
}
- rq_prod_last = s->csf->state;
- rq_cons_last = s->csb->state;
+ rq_prod_last = csf->state;
+ rq_cons_last = csb->state;
req->flags &= ~CF_WAKE_ONCE;
rqf_last = req->flags;
if (((res->flags & ~rpf_last) & CF_MASK_ANALYSER) ||
(res->flags ^ rpf_last) & CF_MASK_STATIC ||
(res->analysers && (res->flags & CF_SHUTW)) ||
- s->csf->state != rp_cons_last ||
- s->csb->state != rp_prod_last ||
+ csf->state != rp_cons_last ||
+ csb->state != rp_prod_last ||
s->pending_events & TASK_WOKEN_MSG) {
unsigned int flags = res->flags;
- if (cs_state_in(s->csb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) {
+ if (cs_state_in(csb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) {
int max_loops = global.tune.maxpollevents;
unsigned int ana_list;
unsigned int ana_back;
}
}
- rp_cons_last = s->csf->state;
- rp_prod_last = s->csb->state;
+ rp_cons_last = csf->state;
+ rp_prod_last = csb->state;
res->flags &= ~CF_WAKE_ONCE;
rpf_last = res->flags;
* the backend stream-interface is in the CS_ST_INI
* state. It is switched into the CS_ST_CLO state and
* the request channel is erased. */
- if (s->csb->state == CS_ST_INI) {
+ if (csb->state == CS_ST_INI) {
s->csb->state = CS_ST_CLO;
channel_abort(req);
if (IS_HTX_STRM(s))
*/
if (unlikely((!req->analysers || (req->analysers == AN_REQ_FLT_END && !(req->flags & CF_FLT_ANALYZE))) &&
!(req->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
- (cs_state_in(s->csf->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) &&
+ (cs_state_in(csf->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO)) &&
(req->to_forward != CHN_INFINITE_FORWARD))) {
/* This buffer is freewheeling, there's no analyser
* attached to it. If any data are left in, we'll permit them to
if (!(req->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
req->to_forward &&
(global.tune.options & GTUNE_USE_SPLICE) &&
- (cs_conn(si_f->cs) && __cs_conn(si_f->cs)->xprt && __cs_conn(si_f->cs)->xprt->rcv_pipe &&
- __cs_conn(si_f->cs)->mux && __cs_conn(si_f->cs)->mux->rcv_pipe) &&
- (cs_conn(si_b->cs) && __cs_conn(si_b->cs)->xprt && __cs_conn(si_b->cs)->xprt->snd_pipe &&
- __cs_conn(si_b->cs)->mux && __cs_conn(si_b->cs)->mux->snd_pipe) &&
+ (cs_conn(csf) && __cs_conn(csf)->xprt && __cs_conn(csf)->xprt->rcv_pipe &&
+ __cs_conn(csf)->mux && __cs_conn(csf)->mux->rcv_pipe) &&
+ (cs_conn(csb) && __cs_conn(csb)->xprt && __cs_conn(csb)->xprt->snd_pipe &&
+ __cs_conn(csb)->mux && __cs_conn(csb)->mux->snd_pipe) &&
(pipes_used < global.maxpipes) &&
(((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
(((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
* - there are data scheduled for emission in the buffer
* - the CF_AUTO_CONNECT flag is set (active connection)
*/
- if (s->csb->state == CS_ST_INI) {
+ if (csb->state == CS_ST_INI) {
if (!(req->flags & CF_SHUTW)) {
if ((req->flags & CF_AUTO_CONNECT) || !channel_is_empty(req)) {
/* If we have an appctx, there is no connect method, so we
* immediately switch to the connected state, otherwise we
* perform a connection request.
*/
- s->csb->state = CS_ST_REQ; /* new connection requested */
+ csb->state = CS_ST_REQ; /* new connection requested */
s->conn_retries = 0;
if ((s->be->retry_type &~ PR_RE_CONN_FAILED) &&
(s->be->mode == PR_MODE_HTTP) &&
}
}
else {
- cs_detach_endp(s->csb);
+ cs_detach_endp(csb);
s->csb->state = CS_ST_CLO; /* shutw+ini = abort */
channel_shutw_now(req); /* fix buffer flags upon abort */
channel_shutr_now(res);
/* we may have a pending connection request, or a connection waiting
* for completion.
*/
- if (cs_state_in(s->csb->state, CS_SB_REQ|CS_SB_QUE|CS_SB_TAR|CS_SB_ASS)) {
+ if (cs_state_in(csb->state, CS_SB_REQ|CS_SB_QUE|CS_SB_TAR|CS_SB_ASS)) {
/* prune the request variables and swap to the response variables. */
if (s->vars_reqres.scope != SCOPE_RES) {
if (!LIST_ISEMPTY(&s->vars_reqres.head))
/* 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.
*/
- if (s->csb->state != CS_ST_REQ)
+ if (csb->state != CS_ST_REQ)
back_try_conn_req(s);
- if (s->csb->state == CS_ST_REQ)
+ if (csb->state == CS_ST_REQ)
back_handle_st_req(s);
/* get a chance to complete an immediate connection setup */
- if (s->csb->state == CS_ST_RDY)
- goto resync_stream_interface;
+ if (csb->state == CS_ST_RDY)
+ goto resync_conn_stream;
/* applets directly go to the ESTABLISHED state. Similarly,
* servers experience the same fate when their connection
* is reused.
*/
- if (unlikely(s->csb->state == CS_ST_EST))
+ if (unlikely(csb->state == CS_ST_EST))
back_establish(s);
srv = objt_server(s->target);
- if (s->csb->state == CS_ST_ASS && srv && srv->rdr_len && (s->flags & SF_REDIRECTABLE))
- http_perform_server_redirect(s, s->csb);
- } while (s->csb->state == CS_ST_ASS);
+ if (csb->state == CS_ST_ASS && srv && srv->rdr_len && (s->flags & SF_REDIRECTABLE))
+ http_perform_server_redirect(s, csb);
+ } while (csb->state == CS_ST_ASS);
}
/* Let's see if we can send the pending request now */
- cs_conn_sync_send(s->csb);
+ cs_conn_sync_send(csb);
/*
* Now forward all shutdown requests between both sides of the request buffer
if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
channel_is_empty(req))) {
if (req->flags & CF_READ_ERROR)
- s->csb->flags |= CS_FL_NOLINGER;
- cs_shutw(s->csb);
+ csb->flags |= CS_FL_NOLINGER;
+ cs_shutw(csb);
}
/* shutdown(write) done on server side, we must stop the client too */
/* shutdown(read) pending */
if (unlikely((req->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
- if (s->csf->flags & CS_FL_NOHALF)
- s->csf->flags |= CS_FL_NOLINGER;
- cs_shutr(s->csf);
+ if (csf->flags & CS_FL_NOHALF)
+ csf->flags |= CS_FL_NOLINGER;
+ cs_shutr(csf);
}
/* Benchmarks have shown that it's optimal to do a full resync now */
- if (s->csf->state == CS_ST_DIS ||
- cs_state_in(s->csb->state, CS_SB_RDY|CS_SB_DIS) ||
- (s->csf->endp->flags & CS_EP_ERROR && s->csf->state != CS_ST_CLO) ||
- (s->csb->endp->flags & CS_EP_ERROR && s->csb->state != CS_ST_CLO))
- goto resync_stream_interface;
+ if (csf->state == CS_ST_DIS ||
+ cs_state_in(csb->state, CS_SB_RDY|CS_SB_DIS) ||
+ (csf->endp->flags & CS_EP_ERROR && csf->state != CS_ST_CLO) ||
+ (csb->endp->flags & CS_EP_ERROR && csb->state != CS_ST_CLO))
+ goto resync_conn_stream;
/* otherwise we want to check if we need to resync the req buffer or not */
if ((req->flags ^ rqf_last) & (CF_SHUTR|CF_SHUTW))
*/
if (unlikely((!res->analysers || (res->analysers == AN_RES_FLT_END && !(res->flags & CF_FLT_ANALYZE))) &&
!(res->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
- cs_state_in(s->csb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO) &&
+ cs_state_in(csb->state, CS_SB_EST|CS_SB_DIS|CS_SB_CLO) &&
(res->to_forward != CHN_INFINITE_FORWARD))) {
/* This buffer is freewheeling, there's no analyser
* attached to it. If any data are left in, we'll permit them to
if (!(res->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
res->to_forward &&
(global.tune.options & GTUNE_USE_SPLICE) &&
- (cs_conn(si_f->cs) && __cs_conn(si_f->cs)->xprt && __cs_conn(si_f->cs)->xprt->snd_pipe &&
- __cs_conn(si_f->cs)->mux && __cs_conn(si_f->cs)->mux->snd_pipe) &&
- (cs_conn(si_b->cs) && __cs_conn(si_b->cs)->xprt && __cs_conn(si_b->cs)->xprt->rcv_pipe &&
- __cs_conn(si_b->cs)->mux && __cs_conn(si_b->cs)->mux->rcv_pipe) &&
+ (cs_conn(csf) && __cs_conn(csf)->xprt && __cs_conn(csf)->xprt->snd_pipe &&
+ __cs_conn(csf)->mux && __cs_conn(csf)->mux->snd_pipe) &&
+ (cs_conn(csb) && __cs_conn(csb)->xprt && __cs_conn(csb)->xprt->rcv_pipe &&
+ __cs_conn(csb)->mux && __cs_conn(csb)->mux->rcv_pipe) &&
(pipes_used < global.maxpipes) &&
(((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
(((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
rpf_last = res->flags;
/* Let's see if we can send the pending response now */
- cs_conn_sync_send(s->csf);
+ cs_conn_sync_send(csf);
/*
* Now forward all shutdown requests between both sides of the buffer
/* shutdown(write) pending */
if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
channel_is_empty(res))) {
- cs_shutw(s->csf);
+ cs_shutw(csf);
}
/* shutdown(write) done on the client side, we must stop the server too */
/* shutdown(read) pending */
if (unlikely((res->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
- if (s->csb->flags & CS_FL_NOHALF)
- s->csb->flags |= CS_FL_NOLINGER;
- cs_shutr(s->csb);
+ if (csb->flags & CS_FL_NOHALF)
+ csb->flags |= CS_FL_NOLINGER;
+ cs_shutr(csb);
}
- if (s->csf->state == CS_ST_DIS ||
- cs_state_in(s->csb->state, CS_SB_RDY|CS_SB_DIS) ||
- (s->csf->endp->flags & CS_EP_ERROR && s->csf->state != CS_ST_CLO) ||
- (s->csb->endp->flags & CS_EP_ERROR && s->csb->state != CS_ST_CLO))
- goto resync_stream_interface;
+ if (csf->state == CS_ST_DIS ||
+ cs_state_in(csb->state, CS_SB_RDY|CS_SB_DIS) ||
+ (csf->endp->flags & CS_EP_ERROR && csf->state != CS_ST_CLO) ||
+ (csb->endp->flags & CS_EP_ERROR && csb->state != CS_ST_CLO))
+ goto resync_conn_stream;
if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER)
goto resync_request;
goto resync_request;
/* we're interested in getting wakeups again */
- s->csf->flags &= ~CS_FL_DONT_WAKE;
- s->csb->flags &= ~CS_FL_DONT_WAKE;
+ csf->flags &= ~CS_FL_DONT_WAKE;
+ csb->flags &= ~CS_FL_DONT_WAKE;
- if (likely((s->csf->state != CS_ST_CLO) || !cs_state_in(s->csb->state, CS_SB_INI|CS_SB_CLO) ||
+ if (likely((csf->state != CS_ST_CLO) || !cs_state_in(csb->state, CS_SB_INI|CS_SB_CLO) ||
(req->analysers & AN_REQ_FLT_END) || (res->analysers & AN_RES_FLT_END))) {
if ((sess->fe->options & PR_O_CONTSTATS) && (s->flags & SF_BE_ASSIGNED) && !(s->flags & SF_IGNORE))
stream_process_counters(s);
(!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) {
chunk_printf(&trash, "%08x:%s.closed[%04x:%04x]\n",
s->uniq_id, s->be->id,
- (unsigned short)conn_fd(cs_conn(si_f->cs)),
- (unsigned short)conn_fd(cs_conn(si_b->cs)));
+ (unsigned short)conn_fd(cs_conn(csf)),
+ (unsigned short)conn_fd(cs_conn(csb)));
DISGUISE(write(1, trash.area, trash.data));
}
const char *dst = "unknown";
char pn[INET6_ADDRSTRLEN];
const struct channel *req, *res;
- const struct stream_interface *si_f, *si_b;
if (!s) {
chunk_appendf(buf, "%sstrm=%p%c", pfx, s, eol);
res = &s->res;
csf = s->csf;
- si_f = cs_si(csf);
cof = cs_conn(csf);
acf = cs_appctx(csf);
if (cof && cof->src && addr_to_str(cof->src, pn, sizeof(pn)) >= 0)
src = acf->applet->name;
csb = s->csb;
- si_b = cs_si(csb);
cob = cs_conn(csb);
acb = cs_appctx(csb);
srv = objt_server(s->target);
chunk_appendf(buf,
"%sstrm=%p,%x src=%s fe=%s be=%s dst=%s%c"
"%stxn=%p,%x txn.req=%s,%x txn.rsp=%s,%x%c"
- "%srqf=%x rqa=%x rpf=%x rpa=%x sif=%x sib=%x%c"
+ "%srqf=%x rqa=%x rpf=%x rpa=%x%c"
"%scsf=%p,%s,%x csb=%p,%s,%x%c"
"%saf=%p,%u sab=%p,%u%c"
"%scof=%p,%x:%s(%p)/%s(%p)/%s(%d)%c"
pfx, s->txn, (s->txn ? s->txn->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,
- pfx, req->flags, req->analysers, res->flags, res->analysers, si_f->flags, si_b->flags, 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, 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),
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);
- chunk_appendf(&trash,
- " si[0]=%p (flags=0x%02x endp0=%s:%p)\n",
- strm->csf->si,
- strm->csf->si->flags,
- (strm->csf->endp->flags & CS_EP_T_MUX ? "CONN" : "APPCTX"),
- __cs_endp_target(strm->csf));
-
- chunk_appendf(&trash,
- " si[1]=%p (flags=0x%02x endp1=%s:%p)\n",
- strm->csb->si,
- strm->csb->si->flags,
- (strm->csb->endp->flags & CS_EP_T_MUX ? "CONN" : "APPCTX"),
- __cs_endp_target(strm->csb));
-
csf = strm->csf;
- chunk_appendf(&trash, " cs=%p csf=0x%08x state=%s endp=%p,0x%08x sub=%d\n", csf, csf->flags,
- cs_state_str(csf->state), csf->endp->target, csf->endp->flags, csf->wait_event.events);
+ chunk_appendf(&trash, " cs=%p csf=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
+ csf, csf->flags, cs_state_str(csf->state),
+ (csf->endp->flags & CS_EP_T_MUX ? "CONN" : "APPCTX"),
+ csf->endp->target, csf->endp->flags, csf->wait_event.events);
if ((conn = cs_conn(csf)) != NULL) {
chunk_appendf(&trash,
}
csb = strm->csb;
- chunk_appendf(&trash, " cs=%p csb=0x%08x state=%s endp=%p,0x%08x sub=%d\n", csb, csb->flags,
- cs_state_str(csb->state), csb->endp->target, csb->endp->flags, csb->wait_event.events);
+ chunk_appendf(&trash, " cs=%p csb=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
+ csb, csb->flags, cs_state_str(csb->state),
+ (csb->endp->flags & CS_EP_T_MUX ? "CONN" : "APPCTX"),
+ csb->endp->target, csb->endp->flags, csb->wait_event.events);
if ((conn = cs_conn(csb)) != NULL) {
chunk_appendf(&trash,
" co1=%p ctrl=%s xprt=%s mux=%s data=%s target=%s:%p\n",
conn = cs_conn(curr_strm->csf);
chunk_appendf(&trash,
- " s0=[%1xh,fd=%d]",
- //curr_strm->csf->si->state,
- curr_strm->csf->si->flags,
+ " csf=[%d,%1xh,fd=%d]",
+ curr_strm->csf->state,
+ curr_strm->csf->flags,
conn_fd(conn));
conn = cs_conn(curr_strm->csb);
chunk_appendf(&trash,
- " s1=[%1xh,fd=%d]",
- //curr_strm->csb->si->state,
- curr_strm->csb->si->flags,
+ " csb=[%d,%1xh,fd=%d]",
+ curr_strm->csb->state,
+ curr_strm->csb->flags,
conn_fd(conn));
chunk_appendf(&trash,
projects / thirdparty / haproxy.git / commitdiff
