diff --git a/src/stream.c b/src/stream.c
index d55b0ba..e0dc824 100644
--- a/src/stream.c
+++ b/src/stream.c
@@ -56,328 +56,15 @@
 /* list of streams waiting for at least one buffer */
 struct list buffer_wq = LIST_HEAD_INIT(buffer_wq);
 
-static int conn_stream_complete(struct connection *conn);
-static int conn_stream_update(struct connection *conn);
-static struct task *expire_mini_session(struct task *t);
-int stream_complete(struct session *s, struct task *t);
-
-/* data layer callbacks for an embryonic stream */
-struct data_cb sess_conn_cb = {
-	.recv = NULL,
-	.send = NULL,
-	.wake = conn_stream_update,
-	.init = conn_stream_complete,
-};
-
-/* This function is called from the protocol layer accept() in order to
- * instanciate a new embryonic stream on behalf of a given listener and
- * frontend. It returns a positive value upon success, 0 if the connection
- * can be ignored, or a negative value upon critical failure. The accepted
- * file descriptor is closed if we return <= 0.
- */
-int stream_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
-{
-	struct connection *cli_conn;
-	struct proxy *p = l->frontend;
-	struct session *sess;
-	struct task *t;
-	int ret;
-
-
-	ret = -1; /* assume unrecoverable error by default */
-
-	if (unlikely((cli_conn = conn_new()) == NULL))
-		goto out_close;
-
-	conn_prepare(cli_conn, l->proto, l->xprt);
-
-	cli_conn->t.sock.fd = cfd;
-	cli_conn->addr.from = *addr;
-	cli_conn->flags |= CO_FL_ADDR_FROM_SET;
-	cli_conn->target = &l->obj_type;
-	cli_conn->proxy_netns = l->netns;
-
-	conn_ctrl_init(cli_conn);
-
-	/* wait for a PROXY protocol header */
-	if (l->options & LI_O_ACC_PROXY) {
-		cli_conn->flags |= CO_FL_ACCEPT_PROXY;
-		conn_sock_want_recv(cli_conn);
-	}
-
-	/* Finish setting the callbacks. Right now the transport layer is present
-	 * but not initialized. Also note we need to be careful as the stream
-	 * int is not initialized yet.
-	 */
-	conn_data_want_recv(cli_conn);
-	if (conn_xprt_init(cli_conn) < 0)
-		goto out_free_conn;
-
-	sess = pool_alloc2(pool2_session);
-	if (!sess)
-		goto out_free_conn;
-
-	p->feconn++;
-	/* This session was accepted, count it now */
-	if (p->feconn > p->fe_counters.conn_max)
-		p->fe_counters.conn_max = p->feconn;
-
-	proxy_inc_fe_conn_ctr(l, p);
-
-	sess->listener = l;
-	sess->fe  = p;
-	sess->origin = &cli_conn->obj_type;
-	sess->accept_date = date; /* user-visible date for logging */
-	sess->tv_accept   = now;  /* corrected date for internal use */
-	memset(sess->stkctr, 0, sizeof(sess->stkctr));
-
-	/* now evaluate the tcp-request layer4 rules. Since we expect to be able
-	 * to abort right here as soon as possible, we check the rules before
-	 * even initializing the stream interfaces.
-	 */
-	if ((l->options & LI_O_TCP_RULES) && !tcp_exec_req_rules(sess)) {
-		/* let's do a no-linger now to close with a single RST. */
-		setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
-		ret = 0; /* successful termination */
-		goto out_free_sess;
-	}
-
-	/* monitor-net and health mode are processed immediately after TCP
-	 * connection rules. This way it's possible to block them, but they
-	 * never use the lower data layers, they send directly over the socket,
-	 * as they were designed for. We first flush the socket receive buffer
-	 * in order to avoid emission of an RST by the system. We ignore any
-	 * error.
-	 */
-	if (unlikely((p->mode == PR_MODE_HEALTH) ||
-		     ((l->options & LI_O_CHK_MONNET) &&
-		      addr->ss_family == AF_INET &&
-		      (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
-		/* we have 4 possibilities here :
-		 *  - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
-		 *  - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
-		 *  - HEALTH mode without HTTP check => just send "OK"
-		 *  - TCP mode from monitoring address => just close
-		 */
-		if (l->proto->drain)
-			l->proto->drain(cfd);
-		if (p->mode == PR_MODE_HTTP ||
-		    (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
-			send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
-		else if (p->mode == PR_MODE_HEALTH)
-			send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
-		ret = 0;
-		goto out_free_sess;
-	}
-
-	if (unlikely((t = task_new()) == NULL))
-		goto out_free_sess;
-
-	t->context = sess;
-	t->nice = l->nice;
-
-	/* OK, now either we have a pending handshake to execute with and
-	 * then we must return to the I/O layer, or we can proceed with the
-	 * end of the stream initialization. In case of handshake, we also
-	 * set the I/O timeout to the frontend's client timeout.
-	 *
-	 * At this point we set the relation between sess/task/conn this way :
-	 *
-	 *          orig -- sess <-- context
-	 *           |                   |
-	 *           v                   |
-	 *          conn -- owner ---> task
-	 */
-	if (cli_conn->flags & CO_FL_HANDSHAKE) {
-		conn_attach(cli_conn, t, &sess_conn_cb);
-		t->process = expire_mini_session;
-		t->expire = tick_add_ifset(now_ms, p->timeout.client);
-		task_queue(t);
-		cli_conn->flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA;
-		return 1;
-	}
-
-	ret = stream_complete(sess, t);
-	if (ret > 0)
-		return ret;
-
-	task_free(t);
- out_free_sess:
-	p->feconn--;
-	session_free(sess);
- out_free_conn:
-	cli_conn->flags &= ~CO_FL_XPRT_TRACKED;
-	conn_xprt_close(cli_conn);
-	conn_free(cli_conn);
- out_close:
-	if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) {
-		/* critical error, no more memory, try to emit a 500 response */
-		struct chunk *err_msg = &p->errmsg[HTTP_ERR_500];
-		if (!err_msg->str)
-			err_msg = &http_err_chunks[HTTP_ERR_500];
-		send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL);
-	}
-
-	if (fdtab[cfd].owner)
-		fd_delete(cfd);
-	else
-		close(cfd);
-	return ret;
-}
-
-
-/* prepare the trash with a log prefix for session <sess>. It only works with
- * embryonic streams based on a real connection. This function requires that
- * at sess->origin points to the incoming connection.
- */
-static void prepare_mini_sess_log_prefix(struct session *sess)
-{
-	struct tm tm;
-	char pn[INET6_ADDRSTRLEN];
-	int ret;
-	char *end;
-	struct connection *cli_conn = __objt_conn(sess->origin);
-
-	ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn));
-	if (ret <= 0)
-		chunk_printf(&trash, "unknown [");
-	else if (ret == AF_UNIX)
-		chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid);
-	else
-		chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from));
-
-	get_localtime(sess->accept_date.tv_sec, &tm);
-	end = date2str_log(trash.str + trash.len, &tm, &(sess->accept_date), trash.size - trash.len);
-	trash.len = end - trash.str;
-	if (sess->listener->name)
-		chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name);
-	else
-		chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid);
-}
-
-/* This function kills an existing embryonic stream. It stops the connection's
- * transport layer, releases assigned resources, resumes the listener if it was
- * disabled and finally kills the file descriptor. This function requires that
- * at sess->origin points to the incoming connection.
- */
-static void kill_mini_session(struct session *sess)
-{
-	int level = LOG_INFO;
-	struct connection *conn = __objt_conn(sess->origin);
-	struct task *task = conn->owner;
-	unsigned int log = sess->fe->to_log;
-	const char *err_msg;
-
-	if (sess->fe->options2 & PR_O2_LOGERRORS)
-		level = LOG_ERR;
-
-	if (log && (sess->fe->options & PR_O_NULLNOLOG)) {
-		/* with "option dontlognull", we don't log connections with no transfer */
-		if (!conn->err_code ||
-		    conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
-		    conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
-			log = 0;
-	}
-
-	if (log) {
-		if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) {
-			if (conn->flags & CO_FL_ACCEPT_PROXY)
-				conn->err_code = CO_ER_PRX_TIMEOUT;
-			else if (conn->flags & CO_FL_SSL_WAIT_HS)
-				conn->err_code = CO_ER_SSL_TIMEOUT;
-		}
-
-		prepare_mini_sess_log_prefix(sess);
-		err_msg = conn_err_code_str(conn);
-		if (err_msg)
-			send_log(sess->fe, level, "%s: %s\n", trash.str, err_msg);
-		else
-			send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
-				 trash.str, conn->err_code, conn->flags);
-	}
-
-	/* kill the connection now */
-	conn_force_close(conn);
-	conn_free(conn);
-
-	sess->fe->feconn--;
-
-	if (!(sess->listener->options & LI_O_UNLIMITED))
-		actconn--;
-	jobs--;
-	sess->listener->nbconn--;
-	if (sess->listener->state == LI_FULL)
-		resume_listener(sess->listener);
-
-	/* Dequeues all of the listeners waiting for a resource */
-	if (!LIST_ISEMPTY(&global_listener_queue))
-		dequeue_all_listeners(&global_listener_queue);
-
-	if (!LIST_ISEMPTY(&sess->fe->listener_queue) &&
-	    (!sess->fe->fe_sps_lim || freq_ctr_remain(&sess->fe->fe_sess_per_sec, sess->fe->fe_sps_lim, 0) > 0))
-		dequeue_all_listeners(&sess->fe->listener_queue);
-
-	task_delete(task);
-	task_free(task);
-	session_free(sess);
-}
-
-/* Finish initializing a stream from a connection, or kills it if the
- * connection shows and error. Returns <0 if the connection was killed.
- */
-static int conn_stream_complete(struct connection *conn)
-{
-	struct task *task = conn->owner;
-	struct session *sess = task->context;
-
-	if (!(conn->flags & CO_FL_ERROR) && (stream_complete(sess, task) > 0)) {
-		conn->flags &= ~CO_FL_INIT_DATA;
-		return 0;
-	}
-
-	/* kill the connection now */
-	kill_mini_session(sess);
-	return -1;
-}
-
-/* Update an embryonic stream status. The connection is killed in case of
- * error, and <0 will be returned. Otherwise it does nothing.
- */
-static int conn_stream_update(struct connection *conn)
-{
-	struct task *task = conn->owner;
-	struct session *sess = task->context;
-
-	if (conn->flags & CO_FL_ERROR) {
-		kill_mini_session(sess);
-		return -1;
-	}
-	return 0;
-}
-
-/* Manages embryonic streams timeout. It is only called when the timeout
- * strikes and performs the required cleanup.
- */
-static struct task *expire_mini_session(struct task *t)
-{
-	struct session *sess = t->context;
-
-	if (!(t->state & TASK_WOKEN_TIMER))
-		return t;
-
-	kill_mini_session(sess);
-	return NULL;
-}
-
-/* This function is called from the I/O handler which detects the end of
+/* This function is called from the session handler which detects the end of
  * handshake, in order to complete initialization of a valid stream. It must
- * be called with an embryonic stream. It returns a positive value upon
+ * be called with an embryonic session. It returns a positive value upon
  * success, 0 if the connection can be ignored, or a negative value upon
  * critical failure. The accepted file descriptor is closed if we return <= 0.
  * The client-side end point is assumed to be a connection, whose pointer is
  * taken from sess->origin which is assumed to be valid.
  */
-int stream_complete(struct session *sess, struct task *t)
+int stream_accept_session(struct session *sess, struct task *t)
 {
 	struct stream *s;
 	struct listener *l = sess->listener;