diff --git a/src/proto_http.c b/src/proto_http.c
index b53bb6c..4581813 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -50,6 +50,7 @@
 #include <proto/queue.h>
 #include <proto/senddata.h>
 #include <proto/session.h>
+#include <proto/stream_sock.h>
 #include <proto/task.h>
 
 #ifdef CONFIG_HAP_TCPSPLICE
@@ -756,7 +757,7 @@
 						buffer_shutw_now(s->req);
 					}
 
-					if (process_srv_data(s))
+					if (stream_sock_process_data(s->req->cons->fd))
 						resync |= PROCESS_SRV;
 
 					/* Count server-side errors (but not timeouts). */
@@ -3863,916 +3864,6 @@
 	return 0;
 }
 
-/*
- * Manages the server FSM and its socket during the DATA phase. It must not be
- * called when a file descriptor is not attached to the buffer. It must only be
- * called during SI_ST_EST. It normally returns zero, but may return 1 if it
- * absolutely wants to be called again.
- */
-int process_srv_data(struct session *t)
-{
-	struct buffer *req = t->req;
-	struct buffer *rep = t->rep;
-	int fd = req->cons->fd;
-
-	DPRINTF(stderr,"[%u] %s: c=%s exp(r,w)=%u,%u req=%08x rep=%08x rql=%d rpl=%d\n",
-		now_ms, __FUNCTION__,
-		cli_stnames[t->cli_state],
-		rep->rex, req->wex,
-		req->flags, rep->flags,
-		req->l, rep->l);
-
-	/* Read or write error on the file descriptor */
-	if (fdtab[fd].state == FD_STERROR) {
-		trace_term(t, TT_HTTP_SRV_6);
-		if (!req->cons->err_type) {
-			req->cons->err_loc = t->srv;
-			req->cons->err_type = SI_ET_DATA_ERR;
-		}
-		buffer_shutw(req);
-		req->flags |= BF_WRITE_ERROR;
-		buffer_shutr(rep);
-		rep->flags |= BF_READ_ERROR;
-
-	do_close_and_return:
-		fd_delete(fd);
-		req->cons->state = SI_ST_CLO;
-		return 0;
-	}
-
-	/* Check if we need to close the read side */
-	if (!(rep->flags & BF_SHUTR)) {
-		/* Last read, forced read-shutdown, or other end closed */
-		if (rep->flags & (BF_READ_NULL|BF_SHUTR_NOW|BF_SHUTW)) {
-			trace_term(t, TT_HTTP_SRV_10);
-		do_close_read:
-			buffer_shutr(rep);
-			if (req->flags & BF_SHUTW)
-				goto do_close_and_return;
-
-			EV_FD_CLR(fd, DIR_RD);
-		}
-		/* Read timeout */
-		else if (unlikely(!(rep->flags & BF_READ_TIMEOUT) && tick_is_expired(rep->rex, now_ms))) {
-			trace_term(t, TT_HTTP_SRV_12);
-			rep->flags |= BF_READ_TIMEOUT;
-			if (!req->cons->err_type) {
-				req->cons->err_loc = t->srv;
-				req->cons->err_type = SI_ET_DATA_TO;
-			}
-			goto do_close_read;
-		}
-		/* Read not closed, update FD status and timeout for reads */
-		else if (rep->flags & (BF_FULL|BF_HIJACK)) {
-			/* stop reading */
-			EV_FD_COND_C(fd, DIR_RD);
-			rep->rex = TICK_ETERNITY;
-		}
-		else {
-			/* (re)start reading and update timeout. Note: we don't recompute the timeout
-			 * everytime we get here, otherwise it would risk never to expire. We only
-			 * update it if is was not yet set, or if we already got some read status.
-			 */
-			EV_FD_COND_S(fd, DIR_RD);
-			if (!tick_isset(rep->rex) || rep->flags & BF_READ_STATUS)
-				rep->rex = tick_add_ifset(now_ms, rep->rto);
-		}
-	}
-
-	/* Check if we need to close the write side */
-	if (!(req->flags & BF_SHUTW)) {
-		/* Forced write-shutdown or other end closed with empty buffer. */
-		if ((req->flags & BF_SHUTW_NOW) ||
-		    (req->flags & (BF_EMPTY|BF_MAY_FORWARD|BF_SHUTR)) == (BF_EMPTY|BF_MAY_FORWARD|BF_SHUTR)) {
-			trace_term(t, TT_HTTP_SRV_11);
-		do_close_write:
-			buffer_shutw(req);
-			if (rep->flags & BF_SHUTR)
-				goto do_close_and_return;
-
-			EV_FD_CLR(fd, DIR_WR);
-			shutdown(fd, SHUT_WR);
-		}
-		/* Write timeout */
-		else if (unlikely(!(req->flags & BF_WRITE_TIMEOUT) && tick_is_expired(req->wex, now_ms))) {
-			trace_term(t, TT_HTTP_SRV_13);
-			req->flags |= BF_WRITE_TIMEOUT;
-			if (!req->cons->err_type) {
-				req->cons->err_loc = t->srv;
-				req->cons->err_type = SI_ET_DATA_TO;
-			}
-			goto do_close_write;
-		}
-		/* Write not closed, update FD status and timeout for writes */
-		else if ((req->flags & (BF_EMPTY|BF_MAY_FORWARD)) != BF_MAY_FORWARD) {
-			/* stop writing */
-			EV_FD_COND_C(fd, DIR_WR);
-			req->wex = TICK_ETERNITY;
-		}
-		else {
-			/* (re)start writing and update timeout. Note: we don't recompute the timeout
-			 * everytime we get here, otherwise it would risk never to expire. We only
-			 * update it if is was not yet set, or if we already got some write status.
-			 */
-			EV_FD_COND_S(fd, DIR_WR);
-			if (!tick_isset(req->wex) || req->flags & BF_WRITE_STATUS) {
-				req->wex = tick_add_ifset(now_ms, req->wto);
-				if (tick_isset(req->wex) && !(rep->flags & BF_SHUTR) && tick_isset(rep->rex)) {
-					/* Note: depending on the protocol, we don't know if we're waiting
-					 * for incoming data or not. So in order to prevent the socket from
-					 * expiring read timeouts during writes, we refresh the read timeout,
-					 * except if it was already infinite.
-					 */
-					rep->rex = req->wex;
-				}
-			}
-		}
-	}
-	return 0; /* other cases change nothing */
-}
-
-
-///*
-// * Manages the client FSM and its socket. It normally returns zero, but may
-// * return 1 if it absolutely wants to be called again.
-// *
-// * Note: process_cli is the ONLY function allowed to set cli_state to anything
-// *       but CL_STCLOSE.
-// */
-//int process_cli(struct session *t)
-//{
-//	struct buffer *req = t->req;
-//	struct buffer *rep = t->rep;
-//
-//	DPRINTF(stderr,"[%u] %s: c=%s set(r,w)=%d,%d exp(r,w)=%u,%u req=%08x rep=%08x rql=%d rpl=%d\n",
-//		now_ms, __FUNCTION__,
-//		cli_stnames[t->cli_state],
-//		t->cli_fd >= 0 && fdtab[t->cli_fd].state != FD_STCLOSE ? EV_FD_ISSET(t->cli_fd, DIR_RD) : 0,
-//		t->cli_fd >= 0 && fdtab[t->cli_fd].state != FD_STCLOSE ? EV_FD_ISSET(t->cli_fd, DIR_WR) : 0,
-//		req->rex, rep->wex,
-//		req->flags, rep->flags,
-//		req->l, rep->l);
-//
-// update_state:
-//	/* FIXME: we still have to check for CL_STSHUTR because client_retnclose
-//	 * still set this state (and will do until unix sockets are converted).
-//	 */
-//	if (t->cli_state == CL_STDATA || t->cli_state == CL_STSHUTR) {
-//		/* we can skip most of the tests at once if some conditions are not met */
-//		if (!((req->flags & (BF_READ_TIMEOUT|BF_READ_ERROR))   ||
-//		      (rep->flags & (BF_WRITE_TIMEOUT|BF_WRITE_ERROR)) ||
-//		      (!(req->flags & BF_SHUTR) && req->flags & (BF_READ_NULL|BF_SHUTW)) ||
-//		      (!(rep->flags & BF_SHUTW) &&
-//		       (rep->flags & (BF_EMPTY|BF_MAY_FORWARD|BF_SHUTR)) == (BF_EMPTY|BF_MAY_FORWARD|BF_SHUTR))))
-//			goto update_timeouts;
-//
-//		/* read or write error */
-//		if (rep->flags & BF_WRITE_ERROR || req->flags & BF_READ_ERROR) {
-//			buffer_shutr(req);
-//			buffer_shutw(rep);
-//			fd_delete(t->cli_fd);
-//			t->cli_state = CL_STCLOSE;
-//			trace_term(t, TT_HTTP_CLI_1);
-//			if (!req->analysers) {
-//				if (!(t->flags & SN_ERR_MASK))
-//					t->flags |= SN_ERR_CLICL;
-//				if (!(t->flags & SN_FINST_MASK)) {
-//					if (t->pend_pos)
-//						t->flags |= SN_FINST_Q;
-//					else if (!(req->flags & BF_CONNECTED))
-//						t->flags |= SN_FINST_C;
-//					else
-//						t->flags |= SN_FINST_D;
-//				}
-//			}
-//			goto update_state;
-//		}
-//		/* last read, or end of server write */
-//		else if (!(req->flags & BF_SHUTR) &&   /* not already done */
-//			 req->flags & (BF_READ_NULL | BF_SHUTW)) {
-//			buffer_shutr(req);
-//			if (!(rep->flags & BF_SHUTW)) {
-//				EV_FD_CLR(t->cli_fd, DIR_RD);
-//				trace_term(t, TT_HTTP_CLI_2);
-//			} else {
-//				/* output was already closed */
-//				fd_delete(t->cli_fd);
-//				t->cli_state = CL_STCLOSE;
-//				trace_term(t, TT_HTTP_CLI_3);
-//			}
-//			goto update_state;
-//		}
-//		/* last server read and buffer empty : we only check them when we're
-//		 * allowed to forward the data.
-//		 */
-//		else if (!(rep->flags & BF_SHUTW) &&   /* not already done */
-//			 rep->flags & BF_EMPTY && rep->flags & BF_MAY_FORWARD &&
-//			 rep->flags & BF_SHUTR && !(t->flags & SN_SELF_GEN)) {
-//			buffer_shutw(rep);
-//			if (!(req->flags & BF_SHUTR)) {
-//				EV_FD_CLR(t->cli_fd, DIR_WR);
-//				shutdown(t->cli_fd, SHUT_WR);
-//				/* We must ensure that the read part is still alive when switching to shutw */
-//				/* FIXME: is this still true ? */
-//				EV_FD_SET(t->cli_fd, DIR_RD);
-//				req->rex = tick_add_ifset(now_ms, t->fe->timeout.client);
-//				trace_term(t, TT_HTTP_CLI_4);
-//			} else {
-//				fd_delete(t->cli_fd);
-//				t->cli_state = CL_STCLOSE;
-//				trace_term(t, TT_HTTP_CLI_5);
-//			}
-//			goto update_state;
-//		}
-//		/* read timeout */
-//		else if ((req->flags & (BF_SHUTR|BF_READ_TIMEOUT)) == BF_READ_TIMEOUT) {
-//			buffer_shutr(req);
-//			if (!(rep->flags & BF_SHUTW)) {
-//				EV_FD_CLR(t->cli_fd, DIR_RD);
-//				trace_term(t, TT_HTTP_CLI_6);
-//			} else {
-//				/* output was already closed */
-//				fd_delete(t->cli_fd);
-//				t->cli_state = CL_STCLOSE;
-//				trace_term(t, TT_HTTP_CLI_7);
-//			}
-//			if (!req->analysers) {
-//				if (!(t->flags & SN_ERR_MASK))
-//					t->flags |= SN_ERR_CLITO;
-//				if (!(t->flags & SN_FINST_MASK)) {
-//					if (t->pend_pos)
-//						t->flags |= SN_FINST_Q;
-//					else if (!(req->flags & BF_CONNECTED))
-//						t->flags |= SN_FINST_C;
-//					else
-//						t->flags |= SN_FINST_D;
-//				}
-//			}
-//			goto update_state;
-//		}
-//		/* write timeout */
-//		else if ((rep->flags & (BF_SHUTW|BF_WRITE_TIMEOUT)) == BF_WRITE_TIMEOUT) {
-//			buffer_shutw(rep);
-//			if (!(req->flags & BF_SHUTR)) {
-//				EV_FD_CLR(t->cli_fd, DIR_WR);
-//				shutdown(t->cli_fd, SHUT_WR);
-//				/* We must ensure that the read part is still alive when switching to shutw */
-//				/* FIXME: is this still true ? */
-//				EV_FD_SET(t->cli_fd, DIR_RD);
-//				req->rex = tick_add_ifset(now_ms, t->fe->timeout.client);
-//				trace_term(t, TT_HTTP_CLI_8);
-//			} else {
-//				fd_delete(t->cli_fd);
-//				t->cli_state = CL_STCLOSE;
-//				trace_term(t, TT_HTTP_CLI_9);
-//			}
-//			if (!req->analysers) {
-//				if (!(t->flags & SN_ERR_MASK))
-//					t->flags |= SN_ERR_CLITO;
-//				if (!(t->flags & SN_FINST_MASK)) {
-//					if (t->pend_pos)
-//						t->flags |= SN_FINST_Q;
-//					else if (!(req->flags & BF_CONNECTED))
-//						t->flags |= SN_FINST_C;
-//					else
-//						t->flags |= SN_FINST_D;
-//				}
-//			}
-//			goto update_state;
-//		}
-//
-//	update_timeouts:
-//		/* manage read timeout */
-//		if (!(req->flags & BF_SHUTR)) {
-//			if (req->flags & BF_FULL) {
-//				/* no room to read more data */
-//				if (EV_FD_COND_C(t->cli_fd, DIR_RD)) {
-//					/* stop reading until we get some space */
-//					req->rex = TICK_ETERNITY;
-//				}
-//			} else {
-//				EV_FD_COND_S(t->cli_fd, DIR_RD);
-//				req->rex = tick_add_ifset(now_ms, t->fe->timeout.client);
-//			}
-//		}
-//
-//		/* manage write timeout */
-//		if (!(rep->flags & BF_SHUTW)) {
-//			/* first, we may have to produce data (eg: stats).
-//			 * right now, this is limited to the SHUTR state.
-//			 */
-//			if (req->flags & BF_SHUTR && t->flags & SN_SELF_GEN) {
-//				produce_content(t);
-//				if (rep->flags & BF_EMPTY) {
-//					buffer_shutw(rep);
-//					fd_delete(t->cli_fd);
-//					t->cli_state = CL_STCLOSE;
-//					trace_term(t, TT_HTTP_CLI_10);
-//					goto update_state;
-//				}
-//			}
-//
-//			/* we don't enable client write if the buffer is empty, nor if the server has to analyze it */
-//			if ((rep->flags & BF_EMPTY) || !(rep->flags & BF_MAY_FORWARD)) {
-//				if (EV_FD_COND_C(t->cli_fd, DIR_WR)) {
-//					/* stop writing */
-//					rep->wex = TICK_ETERNITY;
-//				}
-//			} else {
-//				/* buffer not empty */
-//				EV_FD_COND_S(t->cli_fd, DIR_WR);
-//				if (!tick_isset(rep->wex)) {
-//					/* restart writing */
-//					rep->wex = tick_add_ifset(now_ms, t->fe->timeout.client);
-//					if (!(req->flags & BF_SHUTR) && tick_isset(rep->wex) && tick_isset(req->rex)) {
-//						/* FIXME: to prevent the client from expiring read timeouts during writes,
-//						 * we refresh it, except if it was already infinite. */
-//						req->rex = rep->wex;
-//					}
-//				}
-//			}
-//		}
-//		return 0; /* other cases change nothing */
-//	}
-//	else if (t->cli_state == CL_STCLOSE) { /* CL_STCLOSE: nothing to do */
-//		if ((global.mode & MODE_DEBUG) && (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
-//			int len;
-//			len = sprintf(trash, "%08x:%s.clicls[%04x:%04x]\n", t->uniq_id, t->be->id, (unsigned short)t->cli_fd, (unsigned short)req->cons->fd);
-//			write(1, trash, len);
-//		}
-//		return 0;
-//	}
-//#ifdef DEBUG_DEV
-//	fprintf(stderr, "FIXME !!!! impossible state at %s:%d = %d\n", __FILE__, __LINE__, t->cli_state);
-//	ABORT_NOW();
-//#endif
-//	return 0;
-//}
-//
-//
-///* Return 1 if we could get a new connection for session t, otherwise zero */
-//int tcp_get_connection(struct session *t)
-//{
-//	struct http_txn *txn = &t->txn;
-//	struct buffer *req = t->req;
-//	struct buffer *rep = t->rep;
-//
-//	DPRINTF(stderr,"[%u] %s: c=%s exp(r,w)=%u,%u req=%08x rep=%08x rql=%d rpl=%d\n",
-//		now_ms, __FUNCTION__,
-//		cli_stnames[t->cli_state],
-//		rep->rex, req->wex,
-//		req->flags, rep->flags,
-//		req->l, rep->l);
-//
-//
-//	if ((rep->flags & BF_SHUTW) ||
-//	    ((req->flags & BF_SHUTR) &&
-//	     (req->flags & BF_EMPTY || t->be->options & PR_O_ABRT_CLOSE))) { /* give up */
-//		req->wex = TICK_ETERNITY;
-//		if (t->pend_pos)
-//			t->logs.t_queue = tv_ms_elapsed(&t->logs.tv_accept, &now);
-//		/* note that this must not return any error because it would be able to
-//		 * overwrite the client_retnclose() output.
-//		 */
-//		if (txn->flags & TX_CLTARPIT)
-//			srv_close_with_err(t, SN_ERR_CLICL, SN_FINST_T, 0, NULL);
-//		else
-//			srv_close_with_err(t, SN_ERR_CLICL, t->pend_pos ? SN_FINST_Q : SN_FINST_C, 0, NULL);
-//
-//		trace_term(t, TT_HTTP_SRV_1);
-//		return 0;
-//	}
-//
-//	/* stop here if we're not allowed to connect */
-//	if (!(req->flags & BF_MAY_FORWARD))
-//		return 0;
-//
-//	/* the client allows the server to connect */
-//	if (txn->flags & TX_CLTARPIT) {
-//		/* This connection is being tarpitted. The CLIENT side has
-//		 * already set the connect expiration date to the right
-//		 * timeout. We just have to check that it has not expired.
-//		 */
-//		if (!(req->flags & BF_WRITE_TIMEOUT))
-//			return 0;
-//
-//		/* We will set the queue timer to the time spent, just for
-//		 * logging purposes. We fake a 500 server error, so that the
-//		 * attacker will not suspect his connection has been tarpitted.
-//		 * It will not cause trouble to the logs because we can exclude
-//		 * the tarpitted connections by filtering on the 'PT' status flags.
-//		 */
-//		req->wex = TICK_ETERNITY;
-//		t->logs.t_queue = tv_ms_elapsed(&t->logs.tv_accept, &now);
-//		srv_close_with_err(t, SN_ERR_PRXCOND, SN_FINST_T,
-//				   500, error_message(t, HTTP_ERR_500));
-//		trace_term(t, TT_HTTP_SRV_2);
-//		return 0;
-//	}
-//
-//	/* Right now, we will need to create a connection to the server.
-//	 * We might already have tried, and got a connection pending, in
-//	 * which case we will not do anything till it's pending. It's up
-//	 * to any other session to release it and wake us up again.
-//	 */
-//	if (t->pend_pos) {
-//		if (!(req->flags & BF_WRITE_TIMEOUT)) {
-//			return 0;
-//		} else {
-//			/* we've been waiting too long here */
-//			req->wex = TICK_ETERNITY;
-//			t->logs.t_queue = tv_ms_elapsed(&t->logs.tv_accept, &now);
-//			srv_close_with_err(t, SN_ERR_SRVTO, SN_FINST_Q,
-//					   503, error_message(t, HTTP_ERR_503));
-//			trace_term(t, TT_HTTP_SRV_3);
-//			if (t->srv)
-//				t->srv->failed_conns++;
-//			t->be->failed_conns++;
-//			return 0;
-//		}
-//	}
-//
-//	do {
-//		if (srv_redispatch_connect(t) != 0)
-//			return 0;
-//
-//		if (t->srv && t->srv->rdr_len && t->flags & SN_REDIRECTABLE) {
-//			/* Server supporting redirection and it is possible.
-//			 * Invalid requests are reported as such. It concerns all
-//			 * the largest ones.
-//			 */
-//			struct chunk rdr;
-//			char *path;
-//			int len;
-//
-//			/* 1: create the response header */
-//			rdr.len = strlen(HTTP_302);
-//			rdr.str = trash;
-//			memcpy(rdr.str, HTTP_302, rdr.len);
-//
-//			/* 2: add the server's prefix */
-//			if (rdr.len + t->srv->rdr_len > sizeof(trash))
-//				goto cancel_redir;
-//
-//			memcpy(rdr.str + rdr.len, t->srv->rdr_pfx, t->srv->rdr_len);
-//			rdr.len += t->srv->rdr_len;
-//
-//			/* 3: add the request URI */
-//			path = http_get_path(txn);
-//			if (!path)
-//				goto cancel_redir;
-//			len = txn->req.sl.rq.u_l + (txn->req.sol+txn->req.sl.rq.u) - path;
-//			if (rdr.len + len > sizeof(trash) - 4) /* 4 for CRLF-CRLF */
-//				goto cancel_redir;
-//
-//			memcpy(rdr.str + rdr.len, path, len);
-//			rdr.len += len;
-//			memcpy(rdr.str + rdr.len, "\r\n\r\n", 4);
-//			rdr.len += 4;
-//
-//			srv_close_with_err(t, SN_ERR_PRXCOND, SN_FINST_C, 302, &rdr);
-//			trace_term(t, TT_HTTP_SRV_3);
-//
-//			/* FIXME: we should increase a counter of redirects per server and per backend. */
-//			if (t->srv)
-//				t->srv->cum_sess++;
-//			return 0;
-//		cancel_redir:
-//			txn->status = 400;
-//			t->fe->failed_req++;
-//			srv_close_with_err(t, SN_ERR_PRXCOND, SN_FINST_C,
-//					   400, error_message(t, HTTP_ERR_400));
-//			trace_term(t, TT_HTTP_SRV_4);
-//			return 0;
-//		}
-//
-//		/* try to (re-)connect to the server, and fail if we expire the
-//		 * number of retries.
-//		 */
-//		if (srv_retryable_connect(t)) {
-//			t->logs.t_queue = tv_ms_elapsed(&t->logs.tv_accept, &now);
-//			if (!(req->cons.flags & BC_KNOWN))
-//				return 0;
-//			/* We got an FD */
-//			return 1;
-//		}
-//	} while (1);
-//}
-//
-//
-///* Return 1 if the pending connection has failed and should be retried,
-// * otherwise zero.
-// */
-//int tcp_connection_failed(struct session *t)
-//{
-//	struct buffer *req = t->req;
-//	struct buffer *rep = t->rep;
-//	int conn_err;
-//
-//	DPRINTF(stderr,"[%u] %s: c=%s exp(r,w)=%u,%u req=%08x rep=%08x rql=%d rpl=%d\n",
-//		now_ms, __FUNCTION__,
-//		cli_stnames[t->cli_state],
-//		rep->rex, req->wex,
-//		req->flags, rep->flags,
-//		req->l, rep->l);
-//
-//	if ((rep->flags & BF_SHUTW) ||
-//	    ((req->flags & BF_SHUTR) &&
-//	     ((req->flags & BF_EMPTY && !(req->flags & BF_WRITE_STATUS)) ||
-//	      t->be->options & PR_O_ABRT_CLOSE))) { /* give up */
-//		req->wex = TICK_ETERNITY;
-//		if (!(t->flags & SN_CONN_TAR)) {
-//			/* if we are in turn-around, we have already closed the FD */
-//			fd_delete(req->cons->fd);
-//			req->cons->state = SI_ST_CLO;
-//			if (t->srv) {
-//				t->srv->cur_sess--;
-//				sess_change_server(t, NULL);
-//			}
-//		}
-//
-//		/* note that this must not return any error because it would be able to
-//		 * overwrite the client_retnclose() output.
-//		 */
-//		srv_close_with_err(t, SN_ERR_CLICL, SN_FINST_C, 0, NULL);
-//		trace_term(t, TT_HTTP_SRV_5);
-//		return 0;
-//	}
-//
-//	if (!(req->flags & (BF_WRITE_STATUS | BF_WRITE_TIMEOUT)))
-//		return 0; /* nothing changed */
-//
-//	if (!(req->flags & BF_WRITE_STATUS) || (req->flags & BF_WRITE_ERROR)) {
-//		/* timeout, asynchronous connect error or first write error */
-//		if (t->flags & SN_CONN_TAR) {
-//			/* We are doing a turn-around waiting for a new connection attempt. */
-//			if (!(req->flags & BF_WRITE_TIMEOUT))
-//				return 0;
-//			t->flags &= ~SN_CONN_TAR;
-//		}
-//		else {
-//			fd_delete(req->cons->fd);
-//			req->cons->state = SI_ST_CLO;
-//			if (t->srv) {
-//				t->srv->cur_sess--;
-//				sess_change_server(t, NULL);
-//			}
-//
-//			if (!(req->flags & BF_WRITE_STATUS))
-//				conn_err = SN_ERR_SRVTO; // it was a connect timeout.
-//			else
-//				conn_err = SN_ERR_SRVCL; // it was an asynchronous connect error.
-//
-//			/* ensure that we have enough retries left */
-//			if (srv_count_retry_down(t, conn_err))
-//				return 0;
-//
-//			if (req->flags & BF_WRITE_ERROR) {
-//				/* we encountered an immediate connection error, and we
-//				 * will have to retry connecting to the same server, most
-//				 * likely leading to the same result. To avoid this, we
-//				 * fake a connection timeout to retry after a turn-around
-//				 * time of 1 second. We will wait in the previous if block.
-//				 */
-//				t->flags |= SN_CONN_TAR;
-//				req->wex = tick_add(now_ms, MS_TO_TICKS(1000));
-//				return 0;
-//			}
-//		}
-//
-//		if (t->srv && t->conn_retries == 0 && t->be->options & PR_O_REDISP) {
-//			/* We're on our last chance, and the REDISP option was specified.
-//			 * We will ignore cookie and force to balance or use the dispatcher.
-//			 */
-//			/* let's try to offer this slot to anybody */
-//			if (may_dequeue_tasks(t->srv, t->be))
-//				process_srv_queue(t->srv);
-//
-//			/* it's left to the dispatcher to choose a server */
-//			t->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
-//			t->prev_srv = t->srv;
-//
-//			/* first, get a connection */
-//			if (srv_redispatch_connect(t)) {
-//				if (req->cons.flags & BC_KNOWN)
-//					return 0;
-//				/* we need to get a connection */
-//				return 1;
-//			}
-//		} else {
-//			if (t->srv)
-//				t->srv->retries++;
-//			t->be->retries++;
-//		}
-//
-//		do {
-//			/* Now we will try to either reconnect to the same server or
-//			 * connect to another server. If the connection gets queued
-//			 * because all servers are saturated, then we will go back to
-//			 * the idle state where the buffer's consumer is marked as
-//			 * unknown.
-//			 */
-//			if (srv_retryable_connect(t)) {
-//				t->logs.t_queue = tv_ms_elapsed(&t->logs.tv_accept, &now);
-//				if (req->cons.flags & BC_KNOWN)
-//					return 0;
-//				/* we did not get a connection */
-//				return 1;
-//			}
-//
-//			/* we need to redispatch the connection to another server */
-//			if (srv_redispatch_connect(t)) {
-//				if (req->cons.flags & BC_KNOWN)
-//					return 0;
-//				/* we need to get a connection */
-//				return 1;
-//			}
-//		} while (1);
-//	}
-//	else { /* no error and write OK */
-//		t->logs.t_connect = tv_ms_elapsed(&t->logs.tv_accept, &now);
-//
-//		if (req->flags & BF_EMPTY) {
-//			EV_FD_CLR(req->cons->fd, DIR_WR);
-//			req->wex = TICK_ETERNITY;
-//		} else {
-//			EV_FD_SET(req->cons->fd, DIR_WR);
-//			req->wex = tick_add_ifset(now_ms, t->be->timeout.server);
-//			if (tick_isset(req->wex)) {
-//				/* FIXME: to prevent the server from expiring read timeouts during writes,
-//				 * we refresh it. */
-//				rep->rex = req->wex;
-//			}
-//		}
-//
-//		if (t->be->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */
-//			EV_FD_SET(req->cons->fd, DIR_RD);
-//			rep->rex = tick_add_ifset(now_ms, t->be->timeout.server);
-//			buffer_set_rlim(rep, BUFSIZE); /* no rewrite needed */
-//
-//			/* if the user wants to log as soon as possible, without counting
-//			   bytes from the server, then this is the right moment. */
-//			if (t->fe->to_log && !(t->logs.logwait & LW_BYTES)) {
-//				t->logs.t_close = t->logs.t_connect; /* to get a valid end date */
-//				tcp_sess_log(t);
-//			}
-//#ifdef CONFIG_HAP_TCPSPLICE
-//			if ((t->fe->options & t->be->options) & PR_O_TCPSPLICE) {
-//				/* TCP splicing supported by both FE and BE */
-//				tcp_splice_splicefd(t->cli_fd, req->cons->fd, 0);
-//			}
-//#endif
-//		}
-//		else {
-//			rep->analysers |= AN_RTR_HTTP_HDR;
-//			buffer_set_rlim(rep, BUFSIZE - MAXREWRITE); /* rewrite needed */
-//			t->txn.rsp.msg_state = HTTP_MSG_RPBEFORE;
-//			/* reset hdr_idx which was already initialized by the request.
-//			 * right now, the http parser does it.
-//			 * hdr_idx_init(&t->txn.hdr_idx);
-//			 */
-//		}
-//
-//		req->flags |= BF_CONNECTED;
-//		if (!rep->analysers)
-//			t->rep->flags |= BF_MAY_FORWARD;
-//		req->wex = TICK_ETERNITY;
-//		return 0;
-//	}
-//}
-//
-//
-///*
-// * Tries to establish a connection to the server and associate it to the
-// * request buffer's consumer side. It normally returns zero, but may return 1
-// * if it absolutely wants to be called again.
-// */
-//int process_srv_conn(struct session *t)
-//{
-//	DPRINTF(stderr,"[%u] %s: c=%s exp(r,w)=%u,%u req=%08x rep=%08x rql=%d rpl=%d\n",
-//		now_ms, __FUNCTION__,
-//		cli_stnames[t->cli_state],
-//		t->rep->rex, t->req->wex,
-//		t->req->flags, t->rep->flags,
-//		t->req->l, t->rep->l);
-//
-//	while (!(t->req->flags & BF_CONNECTED)) {
-//		if (!(t->req->cons.flags & BC_KNOWN)) {
-//			/* no connection in progress, get a new one */
-//			if (!tcp_get_connection(t))
-//				break;
-//		} else {
-//			/* connection in progress or just completed */
-//			if (!tcp_connection_failed(t))
-//				break;
-//		}
-//	}
-//	return 0;
-//}
-//
-//
-///*
-// * Manages the server FSM and its socket during the DATA phase. It must not
-// * be called when a file descriptor is not attached to the buffer. It normally
-// * returns zero, but may return 1 if it absolutely wants to be called again.
-// */
-//int process_srv_data(struct session *t)
-//{
-//	struct buffer *req = t->req;
-//	struct buffer *rep = t->rep;
-//
-//	DPRINTF(stderr,"[%u] %s: c=%s exp(r,w)=%u,%u req=%08x rep=%08x rql=%d rpl=%d\n",
-//		now_ms, __FUNCTION__,
-//		cli_stnames[t->cli_state],
-//		rep->rex, req->wex,
-//		req->flags, rep->flags,
-//		req->l, rep->l);
-//
-//	/* we can skip most of the tests at once if some conditions are not met */
-//	if (!((req->flags & (BF_WRITE_TIMEOUT|BF_WRITE_ERROR)) ||
-//	      (!(req->flags & BF_SHUTW) &&
-//	       (req->flags & (BF_EMPTY|BF_MAY_FORWARD)) == (BF_EMPTY|BF_MAY_FORWARD)) ||
-//	      (rep->flags & (BF_READ_TIMEOUT|BF_READ_ERROR)) ||
-//	      (!(rep->flags & BF_SHUTR) && rep->flags & (BF_READ_NULL|BF_SHUTW))))
-//		goto update_timeouts;
-//
-//	/* read or write error */
-//	/* FIXME: what happens when we have to deal with HTTP ??? */
-//	if (req->flags & BF_WRITE_ERROR || rep->flags & BF_READ_ERROR) {
-//		buffer_shutr(rep);
-//		buffer_shutw(req);
-//		fd_delete(req->cons->fd);
-//		req->cons->state = SI_ST_CLO;
-//		if (t->srv) {
-//			t->srv->cur_sess--;
-//			t->srv->failed_resp++;
-//			sess_change_server(t, NULL);
-//		}
-//		t->be->failed_resp++;
-//		trace_term(t, TT_HTTP_SRV_6);
-//		if (!rep->analysers) {
-//			if (!(t->flags & SN_ERR_MASK))
-//				t->flags |= SN_ERR_SRVCL;
-//			if (!(t->flags & SN_FINST_MASK))
-//				t->flags |= SN_FINST_D;
-//		}
-//		if (may_dequeue_tasks(t->srv, t->be))
-//			process_srv_queue(t->srv);
-//
-//		return 0;
-//	}
-//
-//	/* last read, or end of client write */
-//	if (!(rep->flags & BF_SHUTR) &&   /* not already done */
-//		 rep->flags & (BF_READ_NULL | BF_SHUTW)) {
-//		buffer_shutr(rep);
-//		if (!(req->flags & BF_SHUTW)) {
-//			EV_FD_CLR(req->cons->fd, DIR_RD);
-//			trace_term(t, TT_HTTP_SRV_7);
-//		} else {
-//			/* output was already closed */
-//			fd_delete(req->cons->fd);
-//			req->cons->state = SI_ST_CLO;
-//			if (t->srv) {
-//				t->srv->cur_sess--;
-//				sess_change_server(t, NULL);
-//			}
-//			trace_term(t, TT_HTTP_SRV_8);
-//
-//			if (may_dequeue_tasks(t->srv, t->be))
-//				process_srv_queue(t->srv);
-//			return 0;
-//		}
-//	}
-//	/* end of client read and no more data to send. We can forward
-//	 * the close when we're allowed to forward data (anytime right
-//	 * now). If we're using option forceclose, then we may also
-//	 * shutdown the outgoing write channel once the response starts
-//	 * coming from the server.
-//	 */
-//	if (!(req->flags & BF_SHUTW) && /* not already done */
-//	    req->flags & BF_EMPTY && req->flags & BF_MAY_FORWARD &&
-//	    (req->flags & BF_SHUTR ||
-//	     (t->be->options & PR_O_FORCE_CLO && rep->flags & BF_READ_STATUS))) {
-//		buffer_shutw(req);
-//		if (!(rep->flags & BF_SHUTR)) {
-//			EV_FD_CLR(req->cons->fd, DIR_WR);
-//			shutdown(req->cons->fd, SHUT_WR);
-//			trace_term(t, TT_HTTP_SRV_9);
-//			/* We must ensure that the read part is still alive when switching to shutw */
-//			/* FIXME: is this still true ? */
-//			EV_FD_SET(req->cons->fd, DIR_RD);
-//			rep->rex = tick_add_ifset(now_ms, t->be->timeout.server);
-//		} else {
-//			fd_delete(req->cons->fd);
-//			req->cons->state = SI_ST_CLO;
-//			if (t->srv) {
-//				t->srv->cur_sess--;
-//				sess_change_server(t, NULL);
-//			}
-//			trace_term(t, TT_HTTP_SRV_10);
-//
-//			if (may_dequeue_tasks(t->srv, t->be))
-//				process_srv_queue(t->srv);
-//			return 0;
-//		}
-//	}
-//
-//	/* read timeout */
-//	if ((rep->flags & (BF_SHUTR|BF_READ_TIMEOUT)) == BF_READ_TIMEOUT) {
-//		if (!rep->analysers) {
-//			if (!(t->flags & SN_ERR_MASK))
-//				t->flags |= SN_ERR_SRVTO;
-//			if (!(t->flags & SN_FINST_MASK))
-//				t->flags |= SN_FINST_D;
-//		}
-//		buffer_shutr(rep);
-//		if (!(req->flags & BF_SHUTW)) {
-//			EV_FD_CLR(req->cons->fd, DIR_RD);
-//			trace_term(t, TT_HTTP_SRV_11);
-//		} else {
-//			fd_delete(req->cons->fd);
-//			req->cons->state = SI_ST_CLO;
-//			if (t->srv) {
-//				t->srv->cur_sess--;
-//				sess_change_server(t, NULL);
-//			}
-//			trace_term(t, TT_HTTP_SRV_12);
-//
-//			if (may_dequeue_tasks(t->srv, t->be))
-//				process_srv_queue(t->srv);
-//			return 0;
-//		}
-//	}
-//
-//	/* write timeout */
-//	if ((req->flags & (BF_SHUTW|BF_WRITE_TIMEOUT)) == BF_WRITE_TIMEOUT) {
-//		if (!rep->analysers) {
-//			if (!(t->flags & SN_ERR_MASK))
-//				t->flags |= SN_ERR_SRVTO;
-//			if (!(t->flags & SN_FINST_MASK))
-//				t->flags |= SN_FINST_D;
-//		}
-//		buffer_shutw(req);
-//		if (!(rep->flags & BF_SHUTR)) {
-//			EV_FD_CLR(req->cons->fd, DIR_WR);
-//			shutdown(req->cons->fd, SHUT_WR);
-//			/* We must ensure that the read part is still alive when switching to shutw */
-//			/* FIXME: is this still needed ? */
-//			EV_FD_SET(req->cons->fd, DIR_RD);
-//			rep->rex = tick_add_ifset(now_ms, t->be->timeout.server);
-//			trace_term(t, TT_HTTP_SRV_13);
-//		} else {
-//			fd_delete(req->cons->fd);
-//			req->cons->state = SI_ST_CLO;
-//			if (t->srv) {
-//				t->srv->cur_sess--;
-//				sess_change_server(t, NULL);
-//			}
-//			trace_term(t, TT_HTTP_SRV_14);
-//
-//			if (may_dequeue_tasks(t->srv, t->be))
-//				process_srv_queue(t->srv);
-//			return 0;
-//		}
-//	}
-//
-// update_timeouts:
-//	/* manage read timeout */
-//	if (!(rep->flags & BF_SHUTR)) {
-//		if (rep->flags & BF_FULL) {
-//			if (EV_FD_COND_C(req->cons->fd, DIR_RD))
-//				rep->rex = TICK_ETERNITY;
-//		} else {
-//			EV_FD_COND_S(req->cons->fd, DIR_RD);
-//			rep->rex = tick_add_ifset(now_ms, t->be->timeout.server);
-//		}
-//	}
-//
-//	/* manage write timeout */
-//	if (!(req->flags & BF_SHUTW)) {
-//		if (req->flags & BF_EMPTY || !(req->flags & BF_MAY_FORWARD)) {
-//			/* stop writing */
-//			if (EV_FD_COND_C(req->cons->fd, DIR_WR))
-//				req->wex = TICK_ETERNITY;
-//		} else {
-//			/* buffer not empty, there are still data to be transferred */
-//			EV_FD_COND_S(req->cons->fd, DIR_WR);
-//			if (!tick_isset(req->wex)) {
-//				/* restart writing */
-//				req->wex = tick_add_ifset(now_ms, t->be->timeout.server);
-//				if (!(rep->flags & BF_SHUTR) && tick_isset(req->wex) && tick_isset(rep->rex)) {
-//					/* FIXME: to prevent the server from expiring read timeouts during writes,
-//					 * we refresh it, except if it was already infinite.
-//					 */
-//					rep->rex = req->wex;
-//				}
-//			}
-//		}
-//	}
-//	return 0; /* other cases change nothing */
-//}
-//
 
 /*
  * Produces data for the session <s> depending on its source. Expects to be
diff --git a/src/stream_sock.c b/src/stream_sock.c
index cc33b81..a08bf9b 100644
--- a/src/stream_sock.c
+++ b/src/stream_sock.c
@@ -26,6 +26,7 @@
 #include <common/ticks.h>
 #include <common/time.h>
 
+#include <proto/buffers.h>
 #include <proto/client.h>
 #include <proto/fd.h>
 #include <proto/stream_sock.h>
@@ -415,6 +416,134 @@
 }
 
 
+/*
+ * Manages a stream_sock connection during its data phase. The file descriptor
+ * status is checked, and the read and write timeouts are controlled. The
+ * buffers are examined for special shutdown cases and finally the timeouts,
+ * file descriptor and buffers' flags are updated accordingly.
+ */
+int stream_sock_process_data(int fd)
+{
+	struct buffer *ib = fdtab[fd].cb[DIR_RD].b;
+	struct buffer *ob = fdtab[fd].cb[DIR_WR].b;
+
+	DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d\n",
+		now_ms, __FUNCTION__,
+		fd, fdtab[fd].owner,
+		ib, ob,
+		ib->rex, ob->wex,
+		ib->flags, ob->flags,
+		ib->l, ob->l);
+
+	/* Read or write error on the file descriptor */
+	if (fdtab[fd].state == FD_STERROR) {
+		//trace_term(t, TT_HTTP_SRV_6);
+		if (!ob->cons->err_type) {
+			//ob->cons->err_loc = t->srv;
+			ob->cons->err_type = SI_ET_DATA_ERR;
+		}
+		buffer_shutw(ob);
+		ob->flags |= BF_WRITE_ERROR;
+		buffer_shutr(ib);
+		ib->flags |= BF_READ_ERROR;
+
+	do_close_and_return:
+		fd_delete(fd);
+		ob->cons->state = SI_ST_CLO;
+		return 0;
+	}
+
+	/* Check if we need to close the read side */
+	if (!(ib->flags & BF_SHUTR)) {
+		/* Last read, forced read-shutdown, or other end closed */
+		if (ib->flags & (BF_READ_NULL|BF_SHUTR_NOW|BF_SHUTW)) {
+			//trace_term(t, TT_HTTP_SRV_10);
+		do_close_read:
+			buffer_shutr(ib);
+			if (ob->flags & BF_SHUTW)
+				goto do_close_and_return;
+
+			EV_FD_CLR(fd, DIR_RD);
+		}
+		/* Read timeout */
+		else if (unlikely(!(ib->flags & BF_READ_TIMEOUT) && tick_is_expired(ib->rex, now_ms))) {
+			//trace_term(t, TT_HTTP_SRV_12);
+			ib->flags |= BF_READ_TIMEOUT;
+			if (!ob->cons->err_type) {
+				//ob->cons->err_loc = t->srv;
+				ob->cons->err_type = SI_ET_DATA_TO;
+			}
+			goto do_close_read;
+		}
+		/* Read not closed, update FD status and timeout for reads */
+		else if (ib->flags & (BF_FULL|BF_HIJACK)) {
+			/* stop reading */
+			EV_FD_COND_C(fd, DIR_RD);
+			ib->rex = TICK_ETERNITY;
+		}
+		else {
+			/* (re)start reading and update timeout. Note: we don't recompute the timeout
+			 * everytime we get here, otherwise it would risk never to expire. We only
+			 * update it if is was not yet set, or if we already got some read status.
+			 */
+			EV_FD_COND_S(fd, DIR_RD);
+			if (!tick_isset(ib->rex) || ib->flags & BF_READ_STATUS)
+				ib->rex = tick_add_ifset(now_ms, ib->rto);
+		}
+	}
+
+	/* Check if we need to close the write side */
+	if (!(ob->flags & BF_SHUTW)) {
+		/* Forced write-shutdown or other end closed with empty buffer. */
+		if ((ob->flags & BF_SHUTW_NOW) ||
+		    (ob->flags & (BF_EMPTY|BF_MAY_FORWARD|BF_SHUTR)) == (BF_EMPTY|BF_MAY_FORWARD|BF_SHUTR)) {
+			//trace_term(t, TT_HTTP_SRV_11);
+		do_close_write:
+			buffer_shutw(ob);
+			if (ib->flags & BF_SHUTR)
+				goto do_close_and_return;
+
+			EV_FD_CLR(fd, DIR_WR);
+			shutdown(fd, SHUT_WR);
+		}
+		/* Write timeout */
+		else if (unlikely(!(ob->flags & BF_WRITE_TIMEOUT) && tick_is_expired(ob->wex, now_ms))) {
+			//trace_term(t, TT_HTTP_SRV_13);
+			ob->flags |= BF_WRITE_TIMEOUT;
+			if (!ob->cons->err_type) {
+				//ob->cons->err_loc = t->srv;
+				ob->cons->err_type = SI_ET_DATA_TO;
+			}
+			goto do_close_write;
+		}
+		/* Write not closed, update FD status and timeout for writes */
+		else if ((ob->flags & (BF_EMPTY|BF_MAY_FORWARD)) != BF_MAY_FORWARD) {
+			/* stop writing */
+			EV_FD_COND_C(fd, DIR_WR);
+			ob->wex = TICK_ETERNITY;
+		}
+		else {
+			/* (re)start writing and update timeout. Note: we don't recompute the timeout
+			 * everytime we get here, otherwise it would risk never to expire. We only
+			 * update it if is was not yet set, or if we already got some write status.
+			 */
+			EV_FD_COND_S(fd, DIR_WR);
+			if (!tick_isset(ob->wex) || ob->flags & BF_WRITE_STATUS) {
+				ob->wex = tick_add_ifset(now_ms, ob->wto);
+				if (tick_isset(ob->wex) && !(ib->flags & BF_SHUTR) && tick_isset(ib->rex)) {
+					/* Note: depending on the protocol, we don't know if we're waiting
+					 * for incoming data or not. So in order to prevent the socket from
+					 * expiring read timeouts during writes, we refresh the read timeout,
+					 * except if it was already infinite.
+					 */
+					ib->rex = ob->wex;
+				}
+			}
+		}
+	}
+	return 0; /* other cases change nothing */
+}
+
 
 /*
  * Local variables: