diff --git a/src/session.c b/src/session.c
index 053e4a2..83acc4e 100644
--- a/src/session.c
+++ b/src/session.c
@@ -1731,31 +1731,39 @@
 	unsigned int rq_prod_last, rq_cons_last;
 	unsigned int rp_cons_last, rp_prod_last;
 	unsigned int req_ana_back;
+	struct channel *req, *res;
+	struct stream_interface *si_f, *si_b;
+
+	req = &s->req;
+	res = &s->res;
+
+	si_f = &s->si[0];
+	si_b = &s->si[1];
 
 	//DPRINTF(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__,
-	//        s->si[0].state, s->si[1].state, s->si[1].err_type, s->req.flags, s->res.flags);
+	//        si_f->state, si_b->state, si_b->err_type, req->flags, res->flags);
 
 	/* this data may be no longer valid, clear it */
 	memset(&s->txn.auth, 0, sizeof(s->txn.auth));
 
 	/* This flag must explicitly be set every time */
-	s->req.flags &= ~(CF_READ_NOEXP|CF_WAKE_WRITE);
-	s->res.flags &= ~(CF_READ_NOEXP|CF_WAKE_WRITE);
+	req->flags &= ~(CF_READ_NOEXP|CF_WAKE_WRITE);
+	res->flags &= ~(CF_READ_NOEXP|CF_WAKE_WRITE);
 
 	/* Keep a copy of req/rep flags so that we can detect shutdowns */
-	rqf_last = s->req.flags & ~CF_MASK_ANALYSER;
-	rpf_last = s->res.flags & ~CF_MASK_ANALYSER;
+	rqf_last = req->flags & ~CF_MASK_ANALYSER;
+	rpf_last = res->flags & ~CF_MASK_ANALYSER;
 
 	/* we don't want the stream interface functions to recursively wake us up */
-	s->si[0].flags |= SI_FL_DONT_WAKE;
-	s->si[1].flags |= SI_FL_DONT_WAKE;
+	si_f->flags |= SI_FL_DONT_WAKE;
+	si_b->flags |= SI_FL_DONT_WAKE;
 
 	/* 1a: Check for low level timeouts if needed. We just set a flag on
 	 * stream interfaces when their timeouts have expired.
 	 */
 	if (unlikely(t->state & TASK_WOKEN_TIMER)) {
-		stream_int_check_timeouts(&s->si[0]);
-		stream_int_check_timeouts(&s->si[1]);
+		stream_int_check_timeouts(si_f);
+		stream_int_check_timeouts(si_b);
 
 		/* check channel timeouts, and close the corresponding stream interfaces
 		 * for future reads or writes. Note: this will also concern upper layers
@@ -1763,30 +1771,30 @@
 		 * detect state changes when calling them.
 		 */
 
-		channel_check_timeouts(&s->req);
+		channel_check_timeouts(req);
 
-		if (unlikely((s->req.flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
-			s->si[1].flags |= SI_FL_NOLINGER;
-			si_shutw(&s->si[1]);
+		if (unlikely((req->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
+			si_b->flags |= SI_FL_NOLINGER;
+			si_shutw(si_b);
 		}
 
-		if (unlikely((s->req.flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
-			if (s->si[0].flags & SI_FL_NOHALF)
-				s->si[0].flags |= SI_FL_NOLINGER;
-			si_shutr(&s->si[0]);
+		if (unlikely((req->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
+			if (si_f->flags & SI_FL_NOHALF)
+				si_f->flags |= SI_FL_NOLINGER;
+			si_shutr(si_f);
 		}
 
-		channel_check_timeouts(&s->res);
+		channel_check_timeouts(res);
 
-		if (unlikely((s->res.flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
-			s->si[0].flags |= SI_FL_NOLINGER;
-			si_shutw(&s->si[0]);
+		if (unlikely((res->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
+			si_f->flags |= SI_FL_NOLINGER;
+			si_shutw(si_f);
 		}
 
-		if (unlikely((s->res.flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
-			if (s->si[1].flags & SI_FL_NOHALF)
-				s->si[1].flags |= SI_FL_NOLINGER;
-			si_shutr(&s->si[1]);
+		if (unlikely((res->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
+			if (si_b->flags & SI_FL_NOHALF)
+				si_b->flags |= SI_FL_NOLINGER;
+			si_shutr(si_b);
 		}
 
 		/* Once in a while we're woken up because the task expires. But
@@ -1794,10 +1802,10 @@
 		 * So let's not run a whole session processing if only an expiration
 		 * timeout needs to be refreshed.
 		 */
-		if (!((s->req.flags | s->res.flags) &
+		if (!((req->flags | res->flags) &
 		      (CF_SHUTR|CF_READ_ACTIVITY|CF_READ_TIMEOUT|CF_SHUTW|
 		       CF_WRITE_ACTIVITY|CF_WRITE_TIMEOUT|CF_ANA_TIMEOUT)) &&
-		    !((s->si[0].flags | s->si[1].flags) & (SI_FL_EXP|SI_FL_ERR)) &&
+		    !((si_f->flags | si_b->flags) & (SI_FL_EXP|SI_FL_ERR)) &&
 		    ((t->state & TASK_WOKEN_ANY) == TASK_WOKEN_TIMER))
 			goto update_exp_and_leave;
 	}
@@ -1820,12 +1828,12 @@
 	 * connection setup code must be able to deal with any type of abort.
 	 */
 	srv = objt_server(s->target);
-	if (unlikely(s->si[0].flags & SI_FL_ERR)) {
-		if (s->si[0].state == SI_ST_EST || s->si[0].state == SI_ST_DIS) {
-			si_shutr(&s->si[0]);
-			si_shutw(&s->si[0]);
-			stream_int_report_error(&s->si[0]);
-			if (!(s->req.analysers) && !(s->res.analysers)) {
+	if (unlikely(si_f->flags & SI_FL_ERR)) {
+		if (si_f->state == SI_ST_EST || si_f->state == SI_ST_DIS) {
+			si_shutr(si_f);
+			si_shutw(si_f);
+			stream_int_report_error(si_f);
+			if (!(req->analysers) && !(res->analysers)) {
 				s->be->be_counters.cli_aborts++;
 				s->fe->fe_counters.cli_aborts++;
 				if (srv)
@@ -1838,15 +1846,15 @@
 		}
 	}
 
-	if (unlikely(s->si[1].flags & SI_FL_ERR)) {
-		if (s->si[1].state == SI_ST_EST || s->si[1].state == SI_ST_DIS) {
-			si_shutr(&s->si[1]);
-			si_shutw(&s->si[1]);
-			stream_int_report_error(&s->si[1]);
+	if (unlikely(si_b->flags & SI_FL_ERR)) {
+		if (si_b->state == SI_ST_EST || si_b->state == SI_ST_DIS) {
+			si_shutr(si_b);
+			si_shutw(si_b);
+			stream_int_report_error(si_b);
 			s->be->be_counters.failed_resp++;
 			if (srv)
 				srv->counters.failed_resp++;
-			if (!(s->req.analysers) && !(s->res.analysers)) {
+			if (!(req->analysers) && !(res->analysers)) {
 				s->be->be_counters.srv_aborts++;
 				s->fe->fe_counters.srv_aborts++;
 				if (srv)
@@ -1860,14 +1868,14 @@
 		/* note: maybe we should process connection errors here ? */
 	}
 
-	if (s->si[1].state == SI_ST_CON) {
+	if (si_b->state == SI_ST_CON) {
 		/* we were trying to establish a connection on the server side,
 		 * maybe it succeeded, maybe it failed, maybe we timed out, ...
 		 */
-		if (unlikely(!sess_update_st_con_tcp(s, &s->si[1])))
-			sess_update_st_cer(s, &s->si[1]);
-		else if (s->si[1].state == SI_ST_EST)
-			sess_establish(s, &s->si[1]);
+		if (unlikely(!sess_update_st_con_tcp(s, si_b)))
+			sess_update_st_cer(s, si_b);
+		else if (si_b->state == SI_ST_EST)
+			sess_establish(s, si_b);
 
 		/* state is now one of SI_ST_CON (still in progress), SI_ST_EST
 		 * (established), SI_ST_DIS (abort), SI_ST_CLO (last error),
@@ -1875,10 +1883,10 @@
 		 */
 	}
 
-	rq_prod_last = s->si[0].state;
-	rq_cons_last = s->si[1].state;
-	rp_cons_last = s->si[0].state;
-	rp_prod_last = s->si[1].state;
+	rq_prod_last = si_f->state;
+	rq_cons_last = si_b->state;
+	rp_cons_last = si_f->state;
+	rp_prod_last = si_b->state;
 
  resync_stream_interface:
 	/* Check for connection closure */
@@ -1888,22 +1896,22 @@
 		now_ms, __FUNCTION__, __LINE__,
 		t,
 		s, s->flags,
-		s->req, s->rep,
-		s->req.rex, s->res.wex,
-		s->req.flags, s->res.flags,
-		s->req.buf->i, s->req.buf->o, s->res.buf->i, s->res.buf->o, s->si[0].state, s->si[1].state,
-		s->si[0].err_type, s->si[1].err_type,
-		s->si[1].conn_retries);
+		req, res,
+		req->rex, res->wex,
+		req->flags, res->flags,
+		req->buf->i, req->buf->o, res->buf->i, res->buf->o, si_f->state, si_b->state,
+		si_f->err_type, si_b->err_type,
+		si_b->conn_retries);
 
 	/* nothing special to be done on client side */
-	if (unlikely(s->si[0].state == SI_ST_DIS))
-		s->si[0].state = SI_ST_CLO;
+	if (unlikely(si_f->state == SI_ST_DIS))
+		si_f->state = SI_ST_CLO;
 
 	/* When a server-side connection is released, we have to count it and
 	 * check for pending connections on this server.
 	 */
-	if (unlikely(s->si[1].state == SI_ST_DIS)) {
-		s->si[1].state = SI_ST_CLO;
+	if (unlikely(si_b->state == SI_ST_DIS)) {
+		si_b->state = SI_ST_CLO;
 		srv = objt_server(s->target);
 		if (srv) {
 			if (s->flags & SN_CURR_SESS) {
@@ -1923,14 +1931,14 @@
 
  resync_request:
 	/* Analyse request */
-	if (((s->req.flags & ~rqf_last) & CF_MASK_ANALYSER) ||
-	    ((s->req.flags ^ rqf_last) & CF_MASK_STATIC) ||
-	    s->si[0].state != rq_prod_last ||
-	    s->si[1].state != rq_cons_last ||
+	if (((req->flags & ~rqf_last) & CF_MASK_ANALYSER) ||
+	    ((req->flags ^ rqf_last) & CF_MASK_STATIC) ||
+	    si_f->state != rq_prod_last ||
+	    si_b->state != rq_cons_last ||
 	    s->task->state & TASK_WOKEN_MSG) {
-		unsigned int flags = s->req.flags;
+		unsigned int flags = req->flags;
 
-		if (s->si[0].state >= SI_ST_EST) {
+		if (si_f->state >= SI_ST_EST) {
 			int max_loops = global.tune.maxpollevents;
 			unsigned int ana_list;
 			unsigned int ana_back;
@@ -1941,12 +1949,12 @@
 			 * enabling them again when it disables itself, so
 			 * that other analysers are called in similar conditions.
 			 */
-			channel_auto_read(&s->req);
-			channel_auto_connect(&s->req);
-			channel_auto_close(&s->req);
+			channel_auto_read(req);
+			channel_auto_connect(req);
+			channel_auto_close(req);
 
 			/* We will call all analysers for which a bit is set in
-			 * s->req.analysers, following the bit order from LSB
+			 * req->analysers, following the bit order from LSB
 			 * to MSB. The analysers must remove themselves from
 			 * the list when not needed. Any analyser may return 0
 			 * to break out of the loop, either because of missing
@@ -1979,97 +1987,97 @@
 			 * analyser and must immediately loop again.
 			 */
 
-			ana_list = ana_back = s->req.analysers;
+			ana_list = ana_back = req->analysers;
 			while (ana_list && max_loops--) {
 				/* Warning! ensure that analysers are always placed in ascending order! */
 
 				if (ana_list & AN_REQ_INSPECT_FE) {
-					if (!tcp_inspect_request(s, &s->req, AN_REQ_INSPECT_FE))
+					if (!tcp_inspect_request(s, req, AN_REQ_INSPECT_FE))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_INSPECT_FE);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_INSPECT_FE);
 				}
 
 				if (ana_list & AN_REQ_WAIT_HTTP) {
-					if (!http_wait_for_request(s, &s->req, AN_REQ_WAIT_HTTP))
+					if (!http_wait_for_request(s, req, AN_REQ_WAIT_HTTP))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_WAIT_HTTP);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_WAIT_HTTP);
 				}
 
 				if (ana_list & AN_REQ_HTTP_PROCESS_FE) {
-					if (!http_process_req_common(s, &s->req, AN_REQ_HTTP_PROCESS_FE, s->fe))
+					if (!http_process_req_common(s, req, AN_REQ_HTTP_PROCESS_FE, s->fe))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_FE);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_FE);
 				}
 
 				if (ana_list & AN_REQ_SWITCHING_RULES) {
-					if (!process_switching_rules(s, &s->req, AN_REQ_SWITCHING_RULES))
+					if (!process_switching_rules(s, req, AN_REQ_SWITCHING_RULES))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_SWITCHING_RULES);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_SWITCHING_RULES);
 				}
 
 				if (ana_list & AN_REQ_INSPECT_BE) {
-					if (!tcp_inspect_request(s, &s->req, AN_REQ_INSPECT_BE))
+					if (!tcp_inspect_request(s, req, AN_REQ_INSPECT_BE))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_INSPECT_BE);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_INSPECT_BE);
 				}
 
 				if (ana_list & AN_REQ_HTTP_PROCESS_BE) {
-					if (!http_process_req_common(s, &s->req, AN_REQ_HTTP_PROCESS_BE, s->be))
+					if (!http_process_req_common(s, req, AN_REQ_HTTP_PROCESS_BE, s->be))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_BE);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_BE);
 				}
 
 				if (ana_list & AN_REQ_HTTP_TARPIT) {
-					if (!http_process_tarpit(s, &s->req, AN_REQ_HTTP_TARPIT))
+					if (!http_process_tarpit(s, req, AN_REQ_HTTP_TARPIT))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_HTTP_TARPIT);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_TARPIT);
 				}
 
 				if (ana_list & AN_REQ_SRV_RULES) {
-					if (!process_server_rules(s, &s->req, AN_REQ_SRV_RULES))
+					if (!process_server_rules(s, req, AN_REQ_SRV_RULES))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_SRV_RULES);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_SRV_RULES);
 				}
 
 				if (ana_list & AN_REQ_HTTP_INNER) {
-					if (!http_process_request(s, &s->req, AN_REQ_HTTP_INNER))
+					if (!http_process_request(s, req, AN_REQ_HTTP_INNER))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_HTTP_INNER);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_INNER);
 				}
 
 				if (ana_list & AN_REQ_HTTP_BODY) {
-					if (!http_wait_for_request_body(s, &s->req, AN_REQ_HTTP_BODY))
+					if (!http_wait_for_request_body(s, req, AN_REQ_HTTP_BODY))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_HTTP_BODY);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_BODY);
 				}
 
 				if (ana_list & AN_REQ_PRST_RDP_COOKIE) {
-					if (!tcp_persist_rdp_cookie(s, &s->req, AN_REQ_PRST_RDP_COOKIE))
+					if (!tcp_persist_rdp_cookie(s, req, AN_REQ_PRST_RDP_COOKIE))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_PRST_RDP_COOKIE);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_PRST_RDP_COOKIE);
 				}
 
 				if (ana_list & AN_REQ_STICKING_RULES) {
-					if (!process_sticking_rules(s, &s->req, AN_REQ_STICKING_RULES))
+					if (!process_sticking_rules(s, req, AN_REQ_STICKING_RULES))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_STICKING_RULES);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_STICKING_RULES);
 				}
 
 				if (ana_list & AN_REQ_HTTP_XFER_BODY) {
-					if (!http_request_forward_body(s, &s->req, AN_REQ_HTTP_XFER_BODY))
+					if (!http_request_forward_body(s, req, AN_REQ_HTTP_XFER_BODY))
 						break;
-					UPDATE_ANALYSERS(s->req.analysers, ana_list, ana_back, AN_REQ_HTTP_XFER_BODY);
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_XFER_BODY);
 				}
 				break;
 			}
 		}
 
-		rq_prod_last = s->si[0].state;
-		rq_cons_last = s->si[1].state;
-		s->req.flags &= ~CF_WAKE_ONCE;
-		rqf_last = s->req.flags;
+		rq_prod_last = si_f->state;
+		rq_cons_last = si_b->state;
+		req->flags &= ~CF_WAKE_ONCE;
+		rqf_last = req->flags;
 
-		if ((s->req.flags ^ flags) & CF_MASK_STATIC)
+		if ((req->flags ^ flags) & CF_MASK_STATIC)
 			goto resync_request;
 	}
 
@@ -2077,31 +2085,31 @@
 	 * because some response analysers may indirectly enable new request
 	 * analysers (eg: HTTP keep-alive).
 	 */
-	req_ana_back = s->req.analysers;
+	req_ana_back = req->analysers;
 
  resync_response:
 	/* Analyse response */
 
-	if (((s->res.flags & ~rpf_last) & CF_MASK_ANALYSER) ||
-		 (s->res.flags ^ rpf_last) & CF_MASK_STATIC ||
-		 s->si[0].state != rp_cons_last ||
-		 s->si[1].state != rp_prod_last ||
+	if (((res->flags & ~rpf_last) & CF_MASK_ANALYSER) ||
+		 (res->flags ^ rpf_last) & CF_MASK_STATIC ||
+		 si_f->state != rp_cons_last ||
+		 si_b->state != rp_prod_last ||
 		 s->task->state & TASK_WOKEN_MSG) {
-		unsigned int flags = s->res.flags;
+		unsigned int flags = res->flags;
 
-		if ((s->res.flags & CF_MASK_ANALYSER) &&
-		    (s->res.analysers & AN_REQ_ALL)) {
+		if ((res->flags & CF_MASK_ANALYSER) &&
+		    (res->analysers & AN_REQ_ALL)) {
 			/* Due to HTTP pipelining, the HTTP request analyser might be waiting
 			 * for some free space in the response buffer, so we might need to call
 			 * it when something changes in the response buffer, but still we pass
 			 * it the request buffer. Note that the SI state might very well still
 			 * be zero due to us returning a flow of redirects!
 			 */
-			s->res.analysers &= ~AN_REQ_ALL;
-			s->req.flags |= CF_WAKE_ONCE;
+			res->analysers &= ~AN_REQ_ALL;
+			req->flags |= CF_WAKE_ONCE;
 		}
 
-		if (s->si[1].state >= SI_ST_EST) {
+		if (si_b->state >= SI_ST_EST) {
 			int max_loops = global.tune.maxpollevents;
 			unsigned int ana_list;
 			unsigned int ana_back;
@@ -2112,11 +2120,11 @@
 			 * it disables itself, so that other analysers are called
 			 * in similar conditions.
 			 */
-			channel_auto_read(&s->res);
-			channel_auto_close(&s->res);
+			channel_auto_read(res);
+			channel_auto_close(res);
 
 			/* We will call all analysers for which a bit is set in
-			 * s->res.analysers, following the bit order from LSB
+			 * res->analysers, following the bit order from LSB
 			 * to MSB. The analysers must remove themselves from
 			 * the list when not needed. Any analyser may return 0
 			 * to break out of the loop, either because of missing
@@ -2126,56 +2134,56 @@
 			 * are added in the middle.
 			 */
 
-			ana_list = ana_back = s->res.analysers;
+			ana_list = ana_back = res->analysers;
 			while (ana_list && max_loops--) {
 				/* Warning! ensure that analysers are always placed in ascending order! */
 
 				if (ana_list & AN_RES_INSPECT) {
-					if (!tcp_inspect_response(s, &s->res, AN_RES_INSPECT))
+					if (!tcp_inspect_response(s, res, AN_RES_INSPECT))
 						break;
-					UPDATE_ANALYSERS(s->res.analysers, ana_list, ana_back, AN_RES_INSPECT);
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_INSPECT);
 				}
 
 				if (ana_list & AN_RES_WAIT_HTTP) {
-					if (!http_wait_for_response(s, &s->res, AN_RES_WAIT_HTTP))
+					if (!http_wait_for_response(s, res, AN_RES_WAIT_HTTP))
 						break;
-					UPDATE_ANALYSERS(s->res.analysers, ana_list, ana_back, AN_RES_WAIT_HTTP);
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_WAIT_HTTP);
 				}
 
 				if (ana_list & AN_RES_STORE_RULES) {
-					if (!process_store_rules(s, &s->res, AN_RES_STORE_RULES))
+					if (!process_store_rules(s, res, AN_RES_STORE_RULES))
 						break;
-					UPDATE_ANALYSERS(s->res.analysers, ana_list, ana_back, AN_RES_STORE_RULES);
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_STORE_RULES);
 				}
 
 				if (ana_list & AN_RES_HTTP_PROCESS_BE) {
-					if (!http_process_res_common(s, &s->res, AN_RES_HTTP_PROCESS_BE, s->be))
+					if (!http_process_res_common(s, res, AN_RES_HTTP_PROCESS_BE, s->be))
 						break;
-					UPDATE_ANALYSERS(s->res.analysers, ana_list, ana_back, AN_RES_HTTP_PROCESS_BE);
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_HTTP_PROCESS_BE);
 				}
 
 				if (ana_list & AN_RES_HTTP_XFER_BODY) {
-					if (!http_response_forward_body(s, &s->res, AN_RES_HTTP_XFER_BODY))
+					if (!http_response_forward_body(s, res, AN_RES_HTTP_XFER_BODY))
 						break;
-					UPDATE_ANALYSERS(s->res.analysers, ana_list, ana_back, AN_RES_HTTP_XFER_BODY);
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_HTTP_XFER_BODY);
 				}
 				break;
 			}
 		}
 
-		rp_cons_last = s->si[0].state;
-		rp_prod_last = s->si[1].state;
-		rpf_last = s->res.flags;
+		rp_cons_last = si_f->state;
+		rp_prod_last = si_b->state;
+		rpf_last = res->flags;
 
-		if ((s->res.flags ^ flags) & CF_MASK_STATIC)
+		if ((res->flags ^ flags) & CF_MASK_STATIC)
 			goto resync_response;
 	}
 
 	/* maybe someone has added some request analysers, so we must check and loop */
-	if (s->req.analysers & ~req_ana_back)
+	if (req->analysers & ~req_ana_back)
 		goto resync_request;
 
-	if ((s->req.flags & ~rqf_last) & CF_MASK_ANALYSER)
+	if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER)
 		goto resync_request;
 
 	/* FIXME: here we should call protocol handlers which rely on
@@ -2190,24 +2198,24 @@
 	 */
 	srv = objt_server(s->target);
 	if (unlikely(!(s->flags & SN_ERR_MASK))) {
-		if (s->req.flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
+		if (req->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
 			/* Report it if the client got an error or a read timeout expired */
-			s->req.analysers = 0;
-			if (s->req.flags & CF_READ_ERROR) {
+			req->analysers = 0;
+			if (req->flags & CF_READ_ERROR) {
 				s->be->be_counters.cli_aborts++;
 				s->fe->fe_counters.cli_aborts++;
 				if (srv)
 					srv->counters.cli_aborts++;
 				s->flags |= SN_ERR_CLICL;
 			}
-			else if (s->req.flags & CF_READ_TIMEOUT) {
+			else if (req->flags & CF_READ_TIMEOUT) {
 				s->be->be_counters.cli_aborts++;
 				s->fe->fe_counters.cli_aborts++;
 				if (srv)
 					srv->counters.cli_aborts++;
 				s->flags |= SN_ERR_CLITO;
 			}
-			else if (s->req.flags & CF_WRITE_ERROR) {
+			else if (req->flags & CF_WRITE_ERROR) {
 				s->be->be_counters.srv_aborts++;
 				s->fe->fe_counters.srv_aborts++;
 				if (srv)
@@ -2223,24 +2231,24 @@
 			}
 			sess_set_term_flags(s);
 		}
-		else if (s->res.flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
+		else if (res->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
 			/* Report it if the server got an error or a read timeout expired */
-			s->res.analysers = 0;
-			if (s->res.flags & CF_READ_ERROR) {
+			res->analysers = 0;
+			if (res->flags & CF_READ_ERROR) {
 				s->be->be_counters.srv_aborts++;
 				s->fe->fe_counters.srv_aborts++;
 				if (srv)
 					srv->counters.srv_aborts++;
 				s->flags |= SN_ERR_SRVCL;
 			}
-			else if (s->res.flags & CF_READ_TIMEOUT) {
+			else if (res->flags & CF_READ_TIMEOUT) {
 				s->be->be_counters.srv_aborts++;
 				s->fe->fe_counters.srv_aborts++;
 				if (srv)
 					srv->counters.srv_aborts++;
 				s->flags |= SN_ERR_SRVTO;
 			}
-			else if (s->res.flags & CF_WRITE_ERROR) {
+			else if (res->flags & CF_WRITE_ERROR) {
 				s->be->be_counters.cli_aborts++;
 				s->fe->fe_counters.cli_aborts++;
 				if (srv)
@@ -2269,41 +2277,41 @@
 	 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
 	 * recent call to channel_abort().
 	 */
-	if (unlikely(!s->req.analysers &&
-	    !(s->req.flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
-	    (s->si[0].state >= SI_ST_EST) &&
-	    (s->req.to_forward != CHN_INFINITE_FORWARD))) {
+	if (unlikely(!req->analysers &&
+	    !(req->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
+	    (si_f->state >= SI_ST_EST) &&
+	    (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
 		 * move.
 		 */
-		channel_auto_read(&s->req);
-		channel_auto_connect(&s->req);
-		channel_auto_close(&s->req);
-		buffer_flush(s->req.buf);
+		channel_auto_read(req);
+		channel_auto_connect(req);
+		channel_auto_close(req);
+		buffer_flush(req->buf);
 
 		/* We'll let data flow between the producer (if still connected)
 		 * to the consumer (which might possibly not be connected yet).
 		 */
-		if (!(s->req.flags & (CF_SHUTR|CF_SHUTW_NOW)))
-			channel_forward(&s->req, CHN_INFINITE_FORWARD);
+		if (!(req->flags & (CF_SHUTR|CF_SHUTW_NOW)))
+			channel_forward(req, CHN_INFINITE_FORWARD);
 	}
 
 	/* check if it is wise to enable kernel splicing to forward request data */
-	if (!(s->req.flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
-	    s->req.to_forward &&
+	if (!(req->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
+	    req->to_forward &&
 	    (global.tune.options & GTUNE_USE_SPLICE) &&
-	    (objt_conn(s->si[0].end) && __objt_conn(s->si[0].end)->xprt && __objt_conn(s->si[0].end)->xprt->rcv_pipe) &&
-	    (objt_conn(s->si[1].end) && __objt_conn(s->si[1].end)->xprt && __objt_conn(s->si[1].end)->xprt->snd_pipe) &&
+	    (objt_conn(si_f->end) && __objt_conn(si_f->end)->xprt && __objt_conn(si_f->end)->xprt->rcv_pipe) &&
+	    (objt_conn(si_b->end) && __objt_conn(si_b->end)->xprt && __objt_conn(si_b->end)->xprt->snd_pipe) &&
 	    (pipes_used < global.maxpipes) &&
 	    (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
 	     (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
-	      (s->req.flags & CF_STREAMER_FAST)))) {
-		s->req.flags |= CF_KERN_SPLICING;
+	      (req->flags & CF_STREAMER_FAST)))) {
+		req->flags |= CF_KERN_SPLICING;
 	}
 
 	/* reflect what the L7 analysers have seen last */
-	rqf_last = s->req.flags;
+	rqf_last = req->flags;
 
 	/*
 	 * Now forward all shutdown requests between both sides of the buffer
@@ -2314,40 +2322,40 @@
 	 * once the server has begun to respond. If a half-closed timeout is set, we adjust
 	 * the other side's timeout as well.
 	 */
-	if (unlikely((s->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))) {
-		channel_shutw_now(&s->req);
+		channel_shutw_now(req);
 		if (tick_isset(s->fe->timeout.clientfin)) {
-			s->res.wto = s->fe->timeout.clientfin;
-			s->res.wex = tick_add(now_ms, s->res.wto);
+			res->wto = s->fe->timeout.clientfin;
+			res->wex = tick_add(now_ms, res->wto);
 		}
 	}
 
 	/* shutdown(write) pending */
-	if (unlikely((s->req.flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
-		     channel_is_empty(&s->req))) {
-		if (s->req.flags & CF_READ_ERROR)
-			s->si[1].flags |= SI_FL_NOLINGER;
-		si_shutw(&s->si[1]);
+	if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
+		     channel_is_empty(req))) {
+		if (req->flags & CF_READ_ERROR)
+			si_b->flags |= SI_FL_NOLINGER;
+		si_shutw(si_b);
 		if (tick_isset(s->be->timeout.serverfin)) {
-			s->res.rto = s->be->timeout.serverfin;
-			s->res.rex = tick_add(now_ms, s->res.rto);
+			res->rto = s->be->timeout.serverfin;
+			res->rex = tick_add(now_ms, res->rto);
 		}
 	}
 
 	/* shutdown(write) done on server side, we must stop the client too */
-	if (unlikely((s->req.flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW &&
-		     !s->req.analysers))
-		channel_shutr_now(&s->req);
+	if (unlikely((req->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW &&
+		     !req->analysers))
+		channel_shutr_now(req);
 
 	/* shutdown(read) pending */
-	if (unlikely((s->req.flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
-		if (s->si[0].flags & SI_FL_NOHALF)
-			s->si[0].flags |= SI_FL_NOLINGER;
-		si_shutr(&s->si[0]);
+	if (unlikely((req->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
+		if (si_f->flags & SI_FL_NOHALF)
+			si_f->flags |= SI_FL_NOLINGER;
+		si_shutr(si_f);
 		if (tick_isset(s->fe->timeout.clientfin)) {
-			s->res.wto = s->fe->timeout.clientfin;
-			s->res.wex = tick_add(now_ms, s->res.wto);
+			res->wto = s->fe->timeout.clientfin;
+			res->wex = tick_add(now_ms, res->wto);
 		}
 	}
 
@@ -2356,21 +2364,21 @@
 	 *  - there are data scheduled for emission in the buffer
 	 *  - the CF_AUTO_CONNECT flag is set (active connection)
 	 */
-	if (s->si[1].state == SI_ST_INI) {
-		if (!(s->req.flags & CF_SHUTW)) {
-			if ((s->req.flags & CF_AUTO_CONNECT) || !channel_is_empty(&s->req)) {
+	if (si_b->state == SI_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->si[1].state = SI_ST_REQ; /* new connection requested */
-				s->si[1].conn_retries = s->be->conn_retries;
+				si_b->state = SI_ST_REQ; /* new connection requested */
+				si_b->conn_retries = s->be->conn_retries;
 			}
 		}
 		else {
-			s->si[1].state = SI_ST_CLO; /* shutw+ini = abort */
-			channel_shutw_now(&s->req);        /* fix buffer flags upon abort */
-			channel_shutr_now(&s->res);
+			si_b->state = SI_ST_CLO; /* shutw+ini = abort */
+			channel_shutw_now(req);        /* fix buffer flags upon abort */
+			channel_shutr_now(res);
 		}
 	}
 
@@ -2378,26 +2386,26 @@
 	/* we may have a pending connection request, or a connection waiting
 	 * for completion.
 	 */
-	if (s->si[1].state >= SI_ST_REQ && s->si[1].state < SI_ST_CON) {
+	if (si_b->state >= SI_ST_REQ && si_b->state < SI_ST_CON) {
 		do {
 			/* 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->si[1].state != SI_ST_REQ)
-				sess_update_stream_int(s, &s->si[1]);
-			if (s->si[1].state == SI_ST_REQ)
-				sess_prepare_conn_req(s, &s->si[1]);
+			if (si_b->state != SI_ST_REQ)
+				sess_update_stream_int(s, si_b);
+			if (si_b->state == SI_ST_REQ)
+				sess_prepare_conn_req(s, si_b);
 
 			/* applets directly go to the ESTABLISHED state. Similarly,
 			 * servers experience the same fate when their connection
 			 * is reused.
 			 */
-			if (unlikely(s->si[1].state == SI_ST_EST))
-				sess_establish(s, &s->si[1]);
+			if (unlikely(si_b->state == SI_ST_EST))
+				sess_establish(s, si_b);
 
 			/* Now we can add the server name to a header (if requested) */
 			/* check for HTTP mode and proxy server_name_hdr_name != NULL */
-			if ((s->si[1].state >= SI_ST_CON) &&
+			if ((si_b->state >= SI_ST_CON) &&
 			    (s->be->server_id_hdr_name != NULL) &&
 			    (s->be->mode == PR_MODE_HTTP) &&
 			    objt_server(s->target)) {
@@ -2405,17 +2413,17 @@
 			}
 
 			srv = objt_server(s->target);
-			if (s->si[1].state == SI_ST_ASS && srv && srv->rdr_len && (s->flags & SN_REDIRECTABLE))
-				http_perform_server_redirect(s, &s->si[1]);
-		} while (s->si[1].state == SI_ST_ASS);
+			if (si_b->state == SI_ST_ASS && srv && srv->rdr_len && (s->flags & SN_REDIRECTABLE))
+				http_perform_server_redirect(s, si_b);
+		} while (si_b->state == SI_ST_ASS);
 	}
 
 	/* Benchmarks have shown that it's optimal to do a full resync now */
-	if (s->si[0].state == SI_ST_DIS || s->si[1].state == SI_ST_DIS)
+	if (si_f->state == SI_ST_DIS || si_b->state == SI_ST_DIS)
 		goto resync_stream_interface;
 
 	/* otherwise we want to check if we need to resync the req buffer or not */
-	if ((s->req.flags ^ rqf_last) & CF_MASK_STATIC)
+	if ((req->flags ^ rqf_last) & CF_MASK_STATIC)
 		goto resync_request;
 
 	/* perform output updates to the response buffer */
@@ -2425,63 +2433,63 @@
 	 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
 	 * recent call to channel_abort().
 	 */
-	if (unlikely(!s->res.analysers &&
-	    !(s->res.flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
-	    (s->si[1].state >= SI_ST_EST) &&
-	    (s->res.to_forward != CHN_INFINITE_FORWARD))) {
+	if (unlikely(!res->analysers &&
+	    !(res->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
+	    (si_b->state >= SI_ST_EST) &&
+	    (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
 		 * move.
 		 */
-		channel_auto_read(&s->res);
-		channel_auto_close(&s->res);
-		buffer_flush(s->res.buf);
+		channel_auto_read(res);
+		channel_auto_close(res);
+		buffer_flush(res->buf);
 
 		/* We'll let data flow between the producer (if still connected)
 		 * to the consumer.
 		 */
-		if (!(s->res.flags & (CF_SHUTR|CF_SHUTW_NOW)))
-			channel_forward(&s->res, CHN_INFINITE_FORWARD);
+		if (!(res->flags & (CF_SHUTR|CF_SHUTW_NOW)))
+			channel_forward(res, CHN_INFINITE_FORWARD);
 
 		/* if we have no analyser anymore in any direction and have a
 		 * tunnel timeout set, use it now. Note that we must respect
 		 * the half-closed timeouts as well.
 		 */
-		if (!s->req.analysers && s->be->timeout.tunnel) {
-			s->req.rto = s->req.wto = s->res.rto = s->res.wto =
+		if (!req->analysers && s->be->timeout.tunnel) {
+			req->rto = req->wto = res->rto = res->wto =
 				s->be->timeout.tunnel;
 
-			if ((s->req.flags & CF_SHUTR) && tick_isset(s->fe->timeout.clientfin))
-				s->res.wto = s->fe->timeout.clientfin;
-			if ((s->req.flags & CF_SHUTW) && tick_isset(s->be->timeout.serverfin))
-				s->res.rto = s->be->timeout.serverfin;
-			if ((s->res.flags & CF_SHUTR) && tick_isset(s->be->timeout.serverfin))
-				s->req.wto = s->be->timeout.serverfin;
-			if ((s->res.flags & CF_SHUTW) && tick_isset(s->fe->timeout.clientfin))
-				s->req.rto = s->fe->timeout.clientfin;
+			if ((req->flags & CF_SHUTR) && tick_isset(s->fe->timeout.clientfin))
+				res->wto = s->fe->timeout.clientfin;
+			if ((req->flags & CF_SHUTW) && tick_isset(s->be->timeout.serverfin))
+				res->rto = s->be->timeout.serverfin;
+			if ((res->flags & CF_SHUTR) && tick_isset(s->be->timeout.serverfin))
+				req->wto = s->be->timeout.serverfin;
+			if ((res->flags & CF_SHUTW) && tick_isset(s->fe->timeout.clientfin))
+				req->rto = s->fe->timeout.clientfin;
 
-			s->req.rex = tick_add(now_ms, s->req.rto);
-			s->req.wex = tick_add(now_ms, s->req.wto);
-			s->res.rex = tick_add(now_ms, s->res.rto);
-			s->res.wex = tick_add(now_ms, s->res.wto);
+			req->rex = tick_add(now_ms, req->rto);
+			req->wex = tick_add(now_ms, req->wto);
+			res->rex = tick_add(now_ms, res->rto);
+			res->wex = tick_add(now_ms, res->wto);
 		}
 	}
 
 	/* check if it is wise to enable kernel splicing to forward response data */
-	if (!(s->res.flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
-	    s->res.to_forward &&
+	if (!(res->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
+	    res->to_forward &&
 	    (global.tune.options & GTUNE_USE_SPLICE) &&
-	    (objt_conn(s->si[0].end) && __objt_conn(s->si[0].end)->xprt && __objt_conn(s->si[0].end)->xprt->snd_pipe) &&
-	    (objt_conn(s->si[1].end) && __objt_conn(s->si[1].end)->xprt && __objt_conn(s->si[1].end)->xprt->rcv_pipe) &&
+	    (objt_conn(si_f->end) && __objt_conn(si_f->end)->xprt && __objt_conn(si_f->end)->xprt->snd_pipe) &&
+	    (objt_conn(si_b->end) && __objt_conn(si_b->end)->xprt && __objt_conn(si_b->end)->xprt->rcv_pipe) &&
 	    (pipes_used < global.maxpipes) &&
 	    (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
 	     (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
-	      (s->res.flags & CF_STREAMER_FAST)))) {
-		s->res.flags |= CF_KERN_SPLICING;
+	      (res->flags & CF_STREAMER_FAST)))) {
+		res->flags |= CF_KERN_SPLICING;
 	}
 
 	/* reflect what the L7 analysers have seen last */
-	rpf_last = s->res.flags;
+	rpf_last = res->flags;
 
 	/*
 	 * Now forward all shutdown requests between both sides of the buffer
@@ -2492,53 +2500,53 @@
 	 */
 
 	/* first, let's check if the response buffer needs to shutdown(write) */
-	if (unlikely((s->res.flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
+	if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
 		     (CF_AUTO_CLOSE|CF_SHUTR))) {
-		channel_shutw_now(&s->res);
+		channel_shutw_now(res);
 		if (tick_isset(s->be->timeout.serverfin)) {
-			s->req.wto = s->be->timeout.serverfin;
-			s->req.wex = tick_add(now_ms, s->req.wto);
+			req->wto = s->be->timeout.serverfin;
+			req->wex = tick_add(now_ms, req->wto);
 		}
 	}
 
 	/* shutdown(write) pending */
-	if (unlikely((s->res.flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
-		     channel_is_empty(&s->res))) {
-		si_shutw(&s->si[0]);
+	if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
+		     channel_is_empty(res))) {
+		si_shutw(si_f);
 		if (tick_isset(s->fe->timeout.clientfin)) {
-			s->req.rto = s->fe->timeout.clientfin;
-			s->req.rex = tick_add(now_ms, s->req.rto);
+			req->rto = s->fe->timeout.clientfin;
+			req->rex = tick_add(now_ms, req->rto);
 		}
 	}
 
 	/* shutdown(write) done on the client side, we must stop the server too */
-	if (unlikely((s->res.flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW) &&
-	    !s->res.analysers)
-		channel_shutr_now(&s->res);
+	if (unlikely((res->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW) &&
+	    !res->analysers)
+		channel_shutr_now(res);
 
 	/* shutdown(read) pending */
-	if (unlikely((s->res.flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
-		if (s->si[1].flags & SI_FL_NOHALF)
-			s->si[1].flags |= SI_FL_NOLINGER;
-		si_shutr(&s->si[1]);
+	if (unlikely((res->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
+		if (si_b->flags & SI_FL_NOHALF)
+			si_b->flags |= SI_FL_NOLINGER;
+		si_shutr(si_b);
 		if (tick_isset(s->be->timeout.serverfin)) {
-			s->req.wto = s->be->timeout.serverfin;
-			s->req.wex = tick_add(now_ms, s->req.wto);
+			req->wto = s->be->timeout.serverfin;
+			req->wex = tick_add(now_ms, req->wto);
 		}
 	}
 
-	if (s->si[0].state == SI_ST_DIS || s->si[1].state == SI_ST_DIS)
+	if (si_f->state == SI_ST_DIS || si_b->state == SI_ST_DIS)
 		goto resync_stream_interface;
 
-	if (s->req.flags != rqf_last)
+	if (req->flags != rqf_last)
 		goto resync_request;
 
-	if ((s->res.flags ^ rpf_last) & CF_MASK_STATIC)
+	if ((res->flags ^ rpf_last) & CF_MASK_STATIC)
 		goto resync_response;
 
 	/* we're interested in getting wakeups again */
-	s->si[0].flags &= ~SI_FL_DONT_WAKE;
-	s->si[1].flags &= ~SI_FL_DONT_WAKE;
+	si_f->flags &= ~SI_FL_DONT_WAKE;
+	si_b->flags &= ~SI_FL_DONT_WAKE;
 
 	/* This is needed only when debugging is enabled, to indicate
 	 * client-side or server-side close. Please note that in the unlikely
@@ -2548,43 +2556,43 @@
 	if (unlikely((global.mode & MODE_DEBUG) &&
 		     (!(global.mode & MODE_QUIET) ||
 		      (global.mode & MODE_VERBOSE)))) {
-		if (s->si[1].state == SI_ST_CLO &&
-		    s->si[1].prev_state == SI_ST_EST) {
+		if (si_b->state == SI_ST_CLO &&
+		    si_b->prev_state == SI_ST_EST) {
 			chunk_printf(&trash, "%08x:%s.srvcls[%04x:%04x]\n",
 				      s->uniq_id, s->be->id,
-			              objt_conn(s->si[0].end) ? (unsigned short)objt_conn(s->si[0].end)->t.sock.fd : -1,
-			              objt_conn(s->si[1].end) ? (unsigned short)objt_conn(s->si[1].end)->t.sock.fd : -1);
+			              objt_conn(si_f->end) ? (unsigned short)objt_conn(si_f->end)->t.sock.fd : -1,
+			              objt_conn(si_b->end) ? (unsigned short)objt_conn(si_b->end)->t.sock.fd : -1);
 			shut_your_big_mouth_gcc(write(1, trash.str, trash.len));
 		}
 
-		if (s->si[0].state == SI_ST_CLO &&
-		    s->si[0].prev_state == SI_ST_EST) {
+		if (si_f->state == SI_ST_CLO &&
+		    si_f->prev_state == SI_ST_EST) {
 			chunk_printf(&trash, "%08x:%s.clicls[%04x:%04x]\n",
 				      s->uniq_id, s->be->id,
-			              objt_conn(s->si[0].end) ? (unsigned short)objt_conn(s->si[0].end)->t.sock.fd : -1,
-			              objt_conn(s->si[1].end) ? (unsigned short)objt_conn(s->si[1].end)->t.sock.fd : -1);
+			              objt_conn(si_f->end) ? (unsigned short)objt_conn(si_f->end)->t.sock.fd : -1,
+			              objt_conn(si_b->end) ? (unsigned short)objt_conn(si_b->end)->t.sock.fd : -1);
 			shut_your_big_mouth_gcc(write(1, trash.str, trash.len));
 		}
 	}
 
-	if (likely((s->si[0].state != SI_ST_CLO) ||
-		   (s->si[1].state > SI_ST_INI && s->si[1].state < SI_ST_CLO))) {
+	if (likely((si_f->state != SI_ST_CLO) ||
+		   (si_b->state > SI_ST_INI && si_b->state < SI_ST_CLO))) {
 
 		if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SN_BE_ASSIGNED))
 			session_process_counters(s);
 
-		if (s->si[0].state == SI_ST_EST && obj_type(s->si[0].end) != OBJ_TYPE_APPCTX)
-			si_update(&s->si[0]);
+		if (si_f->state == SI_ST_EST && obj_type(si_f->end) != OBJ_TYPE_APPCTX)
+			si_update(si_f);
 
-		if (s->si[1].state == SI_ST_EST && obj_type(s->si[1].end) != OBJ_TYPE_APPCTX)
-			si_update(&s->si[1]);
+		if (si_b->state == SI_ST_EST && obj_type(si_b->end) != OBJ_TYPE_APPCTX)
+			si_update(si_b);
 
-		s->req.flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
-		s->res.flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
-		s->si[0].prev_state = s->si[0].state;
-		s->si[1].prev_state = s->si[1].state;
-		s->si[0].flags &= ~(SI_FL_ERR|SI_FL_EXP);
-		s->si[1].flags &= ~(SI_FL_ERR|SI_FL_EXP);
+		req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
+		res->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
+		si_f->prev_state = si_f->state;
+		si_b->prev_state = si_b->state;
+		si_f->flags &= ~(SI_FL_ERR|SI_FL_EXP);
+		si_b->flags &= ~(SI_FL_ERR|SI_FL_EXP);
 
 		/* Trick: if a request is being waiting for the server to respond,
 		 * and if we know the server can timeout, we don't want the timeout
@@ -2594,10 +2602,10 @@
 		 * request timeout is set and the server has not yet sent a response.
 		 */
 
-		if ((s->res.flags & (CF_AUTO_CLOSE|CF_SHUTR)) == 0 &&
-		    (tick_isset(s->req.wex) || tick_isset(s->res.rex))) {
-			s->req.flags |= CF_READ_NOEXP;
-			s->req.rex = TICK_ETERNITY;
+		if ((res->flags & (CF_AUTO_CLOSE|CF_SHUTR)) == 0 &&
+		    (tick_isset(req->wex) || tick_isset(res->rex))) {
+			req->flags |= CF_READ_NOEXP;
+			req->rex = TICK_ETERNITY;
 		}
 
 		/* When any of the stream interfaces is attached to an applet,
@@ -2609,7 +2617,7 @@
 		 * both functions are always called and that we wake up if at
 		 * least one did something.
 		 */
-		if ((si_applet_call(&s->si[1]) | si_applet_call(&s->si[0])) != 0) {
+		if ((si_applet_call(si_b) | si_applet_call(si_f)) != 0) {
 			if (task_in_rq(t)) {
 				t->expire = TICK_ETERNITY;
 				session_release_buffers(s);
@@ -2618,23 +2626,23 @@
 		}
 
 	update_exp_and_leave:
-		t->expire = tick_first(tick_first(s->req.rex, s->req.wex),
-				       tick_first(s->res.rex, s->res.wex));
-		if (s->req.analysers)
-			t->expire = tick_first(t->expire, s->req.analyse_exp);
+		t->expire = tick_first(tick_first(req->rex, req->wex),
+				       tick_first(res->rex, res->wex));
+		if (req->analysers)
+			t->expire = tick_first(t->expire, req->analyse_exp);
 
-		if (s->si[0].exp)
-			t->expire = tick_first(t->expire, s->si[0].exp);
+		if (si_f->exp)
+			t->expire = tick_first(t->expire, si_f->exp);
 
-		if (s->si[1].exp)
-			t->expire = tick_first(t->expire, s->si[1].exp);
+		if (si_b->exp)
+			t->expire = tick_first(t->expire, si_b->exp);
 
 #ifdef DEBUG_FULL
 		fprintf(stderr,
 			"[%u] queuing with exp=%u req->rex=%u req->wex=%u req->ana_exp=%u"
 			" rep->rex=%u rep->wex=%u, si[0].exp=%u, si[1].exp=%u, cs=%d, ss=%d\n",
-			now_ms, t->expire, s->req.rex, s->req.wex, s->req.analyse_exp,
-			s->res.rex, s->res.wex, s->si[0].exp, s->si[1].exp, s->si[0].state, s->si[1].state);
+			now_ms, t->expire, req->rex, req->wex, req->analyse_exp,
+			res->rex, res->wex, si_f->exp, si_b->exp, si_f->state, si_b->state);
 #endif
 
 #ifdef DEBUG_DEV
@@ -2670,8 +2678,8 @@
 		     (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) {
 		chunk_printf(&trash, "%08x:%s.closed[%04x:%04x]\n",
 			      s->uniq_id, s->be->id,
-		              objt_conn(s->si[0].end) ? (unsigned short)objt_conn(s->si[0].end)->t.sock.fd : -1,
-		              objt_conn(s->si[1].end) ? (unsigned short)objt_conn(s->si[1].end)->t.sock.fd : -1);
+		              objt_conn(si_f->end) ? (unsigned short)objt_conn(si_f->end)->t.sock.fd : -1,
+		              objt_conn(si_b->end) ? (unsigned short)objt_conn(si_b->end)->t.sock.fd : -1);
 		shut_your_big_mouth_gcc(write(1, trash.str, trash.len));
 	}
 
@@ -2702,7 +2710,7 @@
 	/* let's do a final log if we need it */
 	if (!LIST_ISEMPTY(&s->fe->logformat) && s->logs.logwait &&
 	    !(s->flags & SN_MONITOR) &&
-	    (!(s->fe->options & PR_O_NULLNOLOG) || s->req.total)) {
+	    (!(s->fe->options & PR_O_NULLNOLOG) || req->total)) {
 		s->do_log(s);
 	}