diff --git a/lib/fcgi-cli.c b/lib/fcgi-cli.c
index 7c84b25..8420685 100644
--- a/lib/fcgi-cli.c
+++ b/lib/fcgi-cli.c
@@ -26,9 +26,6 @@
 #include <hio-sck.h>
 #include "hio-prv.h"
 
-
-typedef struct hio_svc_fcgic_conn_t hio_svc_fcgic_conn_t;
-
 struct hio_svc_fcgic_t
 {
 	HIO_SVC_HEADER;
@@ -44,14 +41,6 @@ struct hio_svc_fcgic_t
 #define CONN_SESS_INC  (32)
 #define INVALID_SID HIO_TYPE_MAX(hio_oow_t)
 
-struct hio_svc_fcgic_sess_t
-{
-	int active;
-	hio_oow_t sid;
-	hio_svc_fcgic_conn_t* conn;
-	hio_svc_fcgic_on_read_t on_read;
-};
-
 struct hio_svc_fcgic_conn_t
 {
 	hio_svc_fcgic_t* fcgic;
@@ -79,8 +68,9 @@ struct hio_svc_fcgic_conn_t
 		hio_uint16_t  content_len;
 		hio_uint8_t   padding_len;
 
-		hio_uint8_t buf[1024]; /* TODO: make it smaller... */
-		hio_oow_t len;
+		hio_uint32_t body_len; /* content_len+ padding_len */
+		hio_uint8_t buf[65792]; /* TODO: make it smaller by fireing on_read more frequently? */
+		hio_oow_t len; /* current bufferred length */
 	} r; /* space to parse incoming reply header */
 
 	hio_svc_fcgic_conn_t* next;
@@ -92,34 +82,6 @@ struct fcgic_sck_xtn_t
 };
 typedef struct fcgic_sck_xtn_t fcgic_sck_xtn_t;
 
-
-#if 0
-/* ----------------------------------------------------------------------- */
-
-struct fcgic_fcgi_msg_xtn_t
-{
-	hio_dev_sck_t* dev;
-	hio_tmridx_t   rtmridx;
-	//hio_fcgi_msg_t* prev;
-	//hio_fcgi_msg_t* next;
-	hio_skad_t     servaddr;
-	//hio_svc_fcgic_on_done_t on_done;
-	hio_ntime_t    wtmout;
-	hio_ntime_t    rtmout;
-	int            rmaxtries; /* maximum number of tries to receive a reply */
-	int            rtries; /* number of tries made so far */
-	int            pending;
-};
-typedef struct fcgic_fcgi_msg_xtn_t fcgic_fcgi_msg_xtn_t;
-
-#if defined(HIO_HAVE_INLINE)
-	static HIO_INLINE fcgic_fcgi_msg_xtn_t* fcgic_fcgi_msg_getxtn(hio_fcgi_msg_t* msg) { return (fcgic_fcgi_msg_xtn_t*)((hio_uint8_t*)hio_fcgi_msg_to_pkt(msg) + msg->pktalilen); }
-#else
-#	define fcgic_fcgi_msg_getxtn(msg) ((fcgic_fcgi_msg_xtn_t*)((hio_uint8_t*)hio_fcgi_msg_to_pkt(msg) + msg->pktalilen))
-#endif
-
-#endif
-
 static int make_connection_socket (hio_svc_fcgic_conn_t* conn);
 static void release_session (hio_svc_fcgic_sess_t* sess);
 
@@ -185,6 +147,7 @@ static int sck_on_read (hio_dev_sck_t* sck, const void* data, hio_iolen_t dlen,
 	{
 		/* error or timeout */
 /* fire all related fcgi sessions?? -> handled on disconnect */
+		hio_dev_sck_halt (sck);
 	}
 	else if (dlen == 0)
 	{
@@ -194,12 +157,15 @@ static int sck_on_read (hio_dev_sck_t* sck, const void* data, hio_iolen_t dlen,
 	}
 	else
 	{
+printf ("got DATA From FCGI CLIENT>... dlen=%d [%.*s]\n", (int)dlen, (int)dlen, data);		
 		do
 		{
+			hio_iolen_t reqlen, cplen;
+
 			if (conn->r.state == R_AWAITING_HEADER)
 			{
 				hio_fcgi_record_header_t* h;
-				hio_iolen_t reqlen, cplen;
+
 				HIO_ASSERT (hio, conn->r.len < HIO_SIZEOF(*h));
 
 				reqlen = HIO_SIZEOF(*h) - conn->r.len;
@@ -217,44 +183,93 @@ static int sck_on_read (hio_dev_sck_t* sck, const void* data, hio_iolen_t dlen,
 					break;
 				}
 
+				/* header complted */
 				h = (hio_fcgi_record_header_t*)conn->r.buf;
 				conn->r.type = h->type;
 				conn->r.id = hio_ntoh16(h->id);
 				conn->r.content_len = hio_ntoh16(h->content_len);
-				conn->r.padding_len = hio_ntoh16(h->padding_len);
-				conn->r.len = 0;
-				conn->r.state == R_AWAITING_BODY;
+				conn->r.padding_len = h->padding_len;
+
+				conn->r.state = R_AWAITING_BODY;
+				conn->r.body_len = conn->r.content_len + conn->r.padding_len;
+				conn->r.len = 0; /* reset to 0 to use the buffer to hold body */
+printf ("header completed remaining data %d expected body_len %d\n", (int)dlen, (int)conn->r.body_len);
+
+				/* the expected body length must not be too long */
+				HIO_ASSERT (hio, conn->r.body_len <= HIO_SIZEOF(conn->r.buf)); 
+
+				if (conn->r.type == HIO_FCGI_END_REQUEST && conn->r.content_len < HIO_SIZEOF(hio_fcgi_end_request_body_t))
+				{
+					/* invalid content_len encountered */
+					/* TODO: logging*/
+					hio_dev_sck_halt (sck);
+					goto done;
+				}
+
+				if (conn->r.content_len == 0)
+				{
+	printf ("fireing without body\n");
+					goto got_body;
+				}
 			}
 			else /* R_AWAITING_BODY */
 			{
-				switch (conn->r.type)
+				hio_svc_fcgic_sess_t* sess;
+
+				reqlen = conn->r.body_len - conn->r.len;
+				cplen = (dlen > reqlen)? reqlen: dlen;
+				HIO_MEMCPY (&conn->r.buf[conn->r.len], data, cplen);
+				conn->r.len += cplen;
+
+				data += cplen;
+				dlen -= cplen;
+
+				if (conn->r.len < conn->r.body_len)
 				{
-					case HIO_FCGI_END_REQUEST:
-
-					case HIO_FCGI_STDOUT:
-					case HIO_FCGI_STDERR:
-
-					default:
-						/* discard the record */
-						goto done;
+					HIO_ASSERT (hio, dlen == 0);
+					break;
 				}
 
+			got_body:
+				sess = (conn->r.id >= 1 && conn->r.id <= conn->sess.capa)? &conn->sess.ptr[conn->r.id - 1]: HIO_NULL;
 
-				if (conn->r.id >= 1 && conn->r.id <= conn->sess.capa)
+				if (!sess || !sess->active)
 				{
-					hio_svc_fcgic_sess_t* sess;
-					sess = &conn->sess.ptr[conn->r.id - 1];
-					if (sess->active)
+					/* discard the record. no associated sessoin or inactive session */
+					goto back_to_header;
+				}
+
+				/* the complete body is in conn->r.buf */
+				if (conn->r.type == HIO_FCGI_END_REQUEST)
+				{
+					hio_fcgi_end_request_body_t* erb = conn->r.buf;
+
+					if (erb->proto_status != HIO_FCGI_REQUEST_COMPLETE)
 					{
-						sess->on_read (sess, data, dlen);
-						/* TODO: return code check??? */
+						/* error */
+						hio_uint32_t app_status = hio_ntoh32(erb->app_status);
 					}
+					conn->r.content_len = 0; /* to indicate the end of input*/
 				}
-				else
+				else if (conn->r.content_len == 0 || conn->r.type != HIO_FCGI_STDOUT)
 				{
-					/* invalid sid */
-					/* TODO: logging or something*/
+					/* discard the record */
+					/* TODO: log stderr to a file?? or handle it differently according to options given - discard or write to file */
+					/* TODO: logging */
+					goto back_to_header;
 				}
+
+				HIO_ASSERT (hio, conn->r.content_len <= conn->r.len);
+				sess->on_read (sess, conn->r.buf, conn->r.content_len); /* TODO: tell between stdout and stderr */
+
+			back_to_header:
+				conn->r.state = R_AWAITING_HEADER;
+				conn->r.len = 0;
+				conn->r.body_len = 0;
+				conn->r.content_len = 0;
+				conn->r.padding_len = 0;
+
+printf ("body completed remaining data %d\n", (int)dlen);
 			}
 		} while (dlen > 0);
 	}
@@ -386,7 +401,7 @@ static void free_connections (hio_svc_fcgic_t* fcgic)
 	}
 }
 
-static hio_svc_fcgic_sess_t* new_session (hio_svc_fcgic_t* fcgic, const hio_skad_t* fcgis_addr, hio_svc_fcgic_on_read_t on_read)
+static hio_svc_fcgic_sess_t* new_session (hio_svc_fcgic_t* fcgic, const hio_skad_t* fcgis_addr, hio_svc_fcgic_on_read_t on_read, void* ctx)
 {
 	hio_t* hio = fcgic->hio;
 	hio_svc_fcgic_conn_t* conn;
@@ -425,6 +440,7 @@ static hio_svc_fcgic_sess_t* new_session (hio_svc_fcgic_t* fcgic, const hio_skad
 	sess->sid = conn->sess.free;
 	sess->on_read = on_read;
 	sess->active = 1;
+	sess->ctx = ctx;
 	HIO_ASSERT (hio, sess->conn == conn);
 	HIO_ASSERT (hio, sess->conn->fcgic == fcgic);
 
@@ -478,10 +494,10 @@ void hio_svc_fcgic_stop (hio_svc_fcgic_t* fcgic)
 	HIO_DEBUG1 (hio, "FCGIC - STOPPED SERVICE %p\n", fcgic);
 }
 
-hio_svc_fcgic_sess_t* hio_svc_fcgic_tie (hio_svc_fcgic_t* fcgic, const hio_skad_t* addr, hio_svc_fcgic_on_read_t on_read)
+hio_svc_fcgic_sess_t* hio_svc_fcgic_tie (hio_svc_fcgic_t* fcgic, const hio_skad_t* addr, hio_svc_fcgic_on_read_t on_read, void* ctx)
 {
 	/* TODO: reference counting for safety?? */
-	return new_session(fcgic, addr, on_read);
+	return new_session(fcgic, addr, on_read, ctx);
 }
 
 void hio_svc_fcgic_untie (hio_svc_fcgic_sess_t* sess)
@@ -626,4 +642,4 @@ int hio_svc_fcgic_writestdin (hio_svc_fcgic_sess_t* sess, const void* data, hio_
 
 /* TODO: check if sess->conn->dev is still valid */
 	return hio_dev_sck_writev(sess->conn->dev, iov, (size > 0? 2: 1), HIO_NULL, HIO_NULL);
-}
+}
\ No newline at end of file
diff --git a/lib/hio-fcgi.h b/lib/hio-fcgi.h
index 72692fe..7e12363 100644
--- a/lib/hio-fcgi.h
+++ b/lib/hio-fcgi.h
@@ -118,6 +118,7 @@ struct hio_svc_fcgic_tmout_t
 /* ---------------------------------------------------------------- */
 
 typedef struct hio_svc_fcgic_sess_t hio_svc_fcgic_sess_t;
+typedef struct hio_svc_fcgic_conn_t hio_svc_fcgic_conn_t;
 
 /* ---------------------------------------------------------------- */
 
@@ -127,6 +128,15 @@ typedef int (*hio_svc_fcgic_on_read_t) (
    hio_iolen_t           dlen
 );
 
+struct hio_svc_fcgic_sess_t
+{
+	int active;
+	hio_oow_t sid;
+	hio_svc_fcgic_conn_t* conn;
+	hio_svc_fcgic_on_read_t on_read;
+	void* ctx;
+};
+
 /* ---------------------------------------------------------------- */
 #if defined(__cplusplus)
 extern "C" {
@@ -152,7 +162,8 @@ static HIO_INLINE hio_t* hio_svc_fcgic_gethio(hio_svc_fcgic_t* svc) { return hio
 HIO_EXPORT hio_svc_fcgic_sess_t* hio_svc_fcgic_tie (
 	hio_svc_fcgic_t*        fcgic,
 	const hio_skad_t*       fcgis_addr,
-   hio_svc_fcgic_on_read_t on_read
+	hio_svc_fcgic_on_read_t on_read,
+	void*                   ctx
 );
 
 HIO_EXPORT void hio_svc_fcgic_untie (
@@ -177,6 +188,12 @@ HIO_EXPORT int hio_svc_fcgic_writestdin (
    hio_iolen_t           size
 );
 
+#if defined(HIO_HAVE_INLINE)
+static HIO_INLINE void* hio_svc_fcgic_getsessctx (hio_svc_fcgic_sess_t* sess) { return sess->ctx; }
+#else
+#define hio_svc_fcgic_getsessctx(sess) ((sess)->ctx)
+#endif
+
 #if defined(__cplusplus)
 }
 #endif
diff --git a/lib/hio-http.h b/lib/hio-http.h
index 240e4e2..6290997 100644
--- a/lib/hio-http.h
+++ b/lib/hio-http.h
@@ -164,6 +164,11 @@ enum hio_svc_htts_cgi_option_t
 	HIO_SVC_HTTS_CGI_NO_100_CONTINUE = (1 << 0)
 };
 
+enum hio_svc_htts_fcgi_option_t
+{
+	HIO_SVC_HTTS_FCGI_NO_100_CONTINUE = (1 << 0)
+};
+
 enum hio_svc_htts_file_option_t
 {
 	HIO_SVC_HTTS_FILE_NO_100_CONTINUE  = (1 << 0),
diff --git a/lib/http-cgi.c b/lib/http-cgi.c
index 240aee2..5cee647 100644
--- a/lib/http-cgi.c
+++ b/lib/http-cgi.c
@@ -112,7 +112,7 @@ static int cgi_write_to_client (cgi_t* cgi, const void* data, hio_iolen_t dlen)
 		cgi->ever_attempted_to_write_to_client = 1;
 
 		cgi->num_pending_writes_to_client++;
-		if (hio_dev_sck_write(cgi->client->sck, data, dlen, HIO_NULL, HIO_NULL) <= -1)
+		if (hio_dev_sck_write(cgi->csck, data, dlen, HIO_NULL, HIO_NULL) <= -1)
 		{
 			cgi->num_pending_writes_to_client--;
 			return -1;
@@ -134,7 +134,7 @@ static int cgi_writev_to_client (cgi_t* cgi, hio_iovec_t* iov, hio_iolen_t iovcn
 		cgi->ever_attempted_to_write_to_client = 1;
 
 		cgi->num_pending_writes_to_client++;
-		if (hio_dev_sck_writev(cgi->client->sck, iov, iovcnt, HIO_NULL, HIO_NULL) <= -1)
+		if (hio_dev_sck_writev(cgi->csck, iov, iovcnt, HIO_NULL, HIO_NULL) <= -1)
 		{
 			cgi->num_pending_writes_to_client--;
 			return -1;
@@ -280,7 +280,7 @@ static void cgi_on_kill (hio_svc_htts_task_t* task)
 	cgi_t* cgi = (cgi_t*)task;
 	hio_t* hio = cgi->htts->hio;
 
-    HIO_DEBUG5 (hio, "HTTS(%p) - cgi(t=%p,c=%p[%d],p=%p) - killing the task\n", cgi->htts, cgi, cgi->client, (cgi->csck? cgi->csck->hnd: -1), cgi->peer);
+	HIO_DEBUG5 (hio, "HTTS(%p) - cgi(t=%p,c=%p[%d],p=%p) - killing the task\n", cgi->htts, cgi, cgi->client, (cgi->csck? cgi->csck->hnd: -1), cgi->peer);
 
 	if (cgi->peer)
 	{
@@ -304,17 +304,17 @@ static void cgi_on_kill (hio_svc_htts_task_t* task)
 	{
 		HIO_ASSERT (hio, cgi->client != HIO_NULL);
 
-		if (cgi->client_org_on_read) cgi->client->sck->on_read = cgi->client_org_on_read;
-		if (cgi->client_org_on_write) cgi->client->sck->on_write = cgi->client_org_on_write;
-		if (cgi->client_org_on_disconnect) cgi->client->sck->on_disconnect = cgi->client_org_on_disconnect;
+		if (cgi->client_org_on_read) cgi->csck->on_read = cgi->client_org_on_read;
+		if (cgi->client_org_on_write) cgi->csck->on_write = cgi->client_org_on_write;
+		if (cgi->client_org_on_disconnect) cgi->csck->on_disconnect = cgi->client_org_on_disconnect;
 		if (cgi->client_htrd_recbs_changed) hio_htrd_setrecbs (cgi->client->htrd, &cgi->client_htrd_org_recbs);
 
 		if (!cgi->client_disconnected)
 		{
-			if (!cgi->keep_alive || hio_dev_sck_read(cgi->client->sck, 1) <= -1)
+			if (!cgi->keep_alive || hio_dev_sck_read(cgi->csck, 1) <= -1)
 			{
 				HIO_DEBUG5 (hio, "HTTS(%p) - cgi(t=%p,c=%p[%d],p=%p) - halting client for failure to enable input watching\n", cgi->htts, cgi, cgi->client, (cgi->csck? cgi->csck->hnd: -1), cgi->peer);
-				hio_dev_sck_halt (cgi->client->sck);
+				hio_dev_sck_halt (cgi->csck);
 			}
 		}
 
@@ -664,7 +664,7 @@ static int cgi_peer_on_write (hio_dev_pro_t* pro, hio_iolen_t wrlen, void* wrctx
 		if (cgi->num_pending_writes_to_peer == CGI_PENDING_IO_THRESHOLD)
 		{
 			if (!(cgi->over & CGI_OVER_READ_FROM_CLIENT) &&
-			    hio_dev_sck_read(cgi->client->sck, 1) <= -1) goto oops;
+			    hio_dev_sck_read(cgi->csck, 1) <= -1) goto oops;
 		}
 
 		if ((cgi->over & CGI_OVER_READ_FROM_CLIENT) && cgi->num_pending_writes_to_peer <= 0)
diff --git a/lib/http-fcgi.c b/lib/http-fcgi.c
index 728c2a8..e6578c1 100644
--- a/lib/http-fcgi.c
+++ b/lib/http-fcgi.c
@@ -29,6 +29,7 @@ struct fcgi_t
 	hio_oow_t num_pending_writes_to_client;
 	hio_oow_t num_pending_writes_to_peer;
 	hio_svc_fcgic_sess_t* peer;
+	hio_htrd_t* peer_htrd;
 
 	hio_dev_sck_t* csck;
 	hio_svc_htts_cli_t* client;
@@ -40,6 +41,7 @@ struct fcgi_t
 	unsigned int req_content_length_unlimited: 1;
 	unsigned int ever_attempted_to_write_to_client: 1;
 	unsigned int client_disconnected: 1;
+	unsigned int client_eof_detected: 1;
 	unsigned int client_htrd_recbs_changed: 1;
 	hio_oow_t req_content_length; /* client request content length */
 	fcgi_res_mode_t res_mode_to_cli;
@@ -51,36 +53,11 @@ struct fcgi_t
 };
 typedef struct fcgi_t fcgi_t;
 
-
-#if 0
-static int begin_request ()
+struct fcgi_peer_xtn_t
 {
-	struct fcgi_record_header* h;
-	struct fcgi_begin_request_body* br;
-
-	h->version = FCGI_VERSION;
-	h->type = FCGI_BEGIN_REQUEST;
-
-	h->id = HIO_CONST_HTON16(1);
-	h->content_len = HIO_HTON16(HIO_SIZEOF(struct fcgi_begin_request_body));
-	h->padding_len = 0;
-
-
-	br->role = HIO_CONST_HTON16(FCGI_RESPONDER);
-	br->flags = 0;
-
-
-	h->type = FCGI_PARAMS;
-	h->content_len = 0;
-
-
-/*
-	h->type = FCGI_STDIN;
-*/
-
-}
-
-#endif
+	fcgi_t* fcgi; /* back pointer to the fcgi object */
+};
+typedef struct fcgi_peer_xtn_t fcgi_peer_xtn_t;
 
 static void fcgi_halt_participating_devices (fcgi_t* fcgi)
 {
@@ -92,108 +69,56 @@ static void fcgi_halt_participating_devices (fcgi_t* fcgi)
 
 	hio_dev_sck_halt (fcgi->csck);
 
-#if 0
 	/* check for peer as it may not have been started */
-/* TODO: send abort if the transmission didn't end ... */
-	if (fcgi->peer) hio_dev_pro_halt (fcgi->peer);
-#endif
-}
-
-static int fcgi_write_to_peer (fcgi_t* fcgi, const void* data, hio_iolen_t dlen)
-{
-#if 0
-	fcgi->num_pending_writes_to_peer++;
-	if (hio_dev_pro_write(fcgi->peer, data, dlen, HIO_NULL) <= -1)
+	if (fcgi->peer)
 	{
-		fcgi->num_pending_writes_to_peer--;
-		return -1;
-	}
-#endif
-
-/* TODO: check if it's already finished or something.. */
-	if (fcgi->num_pending_writes_to_peer > FCGI_PENDING_IO_THRESHOLD)
-	{
-		/* disable input watching */
-		if (hio_dev_sck_read(fcgi->csck, 0) <= -1) return -1;
-	}
-	return 0;
-}
-
-static HIO_INLINE void fcgi_mark_over (fcgi_t* fcgi, int over_bits)
-{
-	unsigned int old_over;
-
-	old_over = fcgi->over;
-	fcgi->over |= over_bits;
-
-	HIO_DEBUG4 (fcgi->htts->hio, "HTTS(%p) - client=%p new-bits=%x over=%x\n", fcgi->htts, fcgi->csck, (int)over_bits, (int)fcgi->over);
-
-	if (!(old_over & FCGI_OVER_READ_FROM_CLIENT) && (fcgi->over & FCGI_OVER_READ_FROM_CLIENT))
-	{
-printf (">>>>>>>>>>>> disableing client read watching ...................\n");
-		if (hio_dev_sck_read(fcgi->csck, 0) <= -1)
-		{
-			HIO_DEBUG2 (fcgi->htts->hio, "HTTS(%p) - halting client(%p) for failure to disable input watching\n", fcgi->htts, fcgi->csck);
-			hio_dev_sck_halt (fcgi->csck);
-		}
-	}
-
-	if (!(old_over & FCGI_OVER_READ_FROM_PEER) && (fcgi->over & FCGI_OVER_READ_FROM_PEER))
-	{
-#if 0 // TODO:
-		if (fcgi->peer && hio_dev_pro_read(fcgi->peer, HIO_DEV_PRO_OUT, 0) <= -1)
-		{
-			HIO_DEBUG2 (fcgi->htts->hio, "HTTS(%p) - halting peer(%p) for failure to disable input watching\n", fcgi->htts, fcgi->peer);
-			hio_dev_pro_halt (fcgi->peer);
-		}
-#endif
-	}
-
-	if (old_over != FCGI_OVER_ALL && fcgi->over == FCGI_OVER_ALL)
-	{
-		/* ready to stop */
-#if 0 // TODO:
-		if (fcgi->peer)
-		{
-			HIO_DEBUG2 (fcgi->htts->hio, "HTTS(%p) - halting peer(%p) as it is unneeded\n", fcgi->htts, fcgi->peer);
-			hio_dev_pro_halt (fcgi->peer);
-		}
-#endif
-
-		if (fcgi->keep_alive)
-		{
-			/* how to arrange to delete this fcgi object and put the socket back to the normal waiting state??? */
-			HIO_ASSERT (fcgi->htts->hio, fcgi->client->task == (hio_svc_htts_task_t*)fcgi);
-
-/*printf ("DETACHING FROM THE MAIN CLIENT TASK... state -> %p\n", fcgi->client->task);*/
-			HIO_SVC_HTTS_TASK_UNREF (fcgi->client->task);
-			/* fcgi must not be accessed from here down as it could have been destroyed */
-		}
-		else
-		{
-			HIO_DEBUG2 (fcgi->htts->hio, "HTTS(%p) - halting client(%p) for no keep-alive\n", fcgi->htts, fcgi->csck);
-			hio_dev_sck_shutdown (fcgi->csck, HIO_DEV_SCK_SHUTDOWN_WRITE);
-			hio_dev_sck_halt (fcgi->csck);
-		}
+		hio_svc_fcgic_untie (fcgi->peer); /* this is not a delayed operation unlike hio_dev_sck_halt. TODO: check if this is a buggy idea */
+		fcgi->peer = HIO_NULL;
 	}
 }
 
 static int fcgi_write_to_client (fcgi_t* fcgi, const void* data, hio_iolen_t dlen)
 {
-	fcgi->ever_attempted_to_write_to_client = 1;
-
-	fcgi->num_pending_writes_to_client++;
-	if (hio_dev_sck_write(fcgi->csck, data, dlen, HIO_NULL, HIO_NULL) <= -1)
+	if (fcgi->csck)
 	{
-		fcgi->num_pending_writes_to_client--;
-		return -1;
+		fcgi->ever_attempted_to_write_to_client = 1;
+
+		fcgi->num_pending_writes_to_client++;
+		if (hio_dev_sck_write(fcgi->csck, data, dlen, HIO_NULL, HIO_NULL) <= -1)
+		{
+			fcgi->num_pending_writes_to_client--;
+			return -1;
+		}
+
+		if (fcgi->num_pending_writes_to_client > FCGI_PENDING_IO_THRESHOLD)
+		{
+			/* disable reading on the output stream of the peer */
+	#if 0 // TODO
+			if (hio_dev_pro_read(fcgi->peer, HIO_DEV_PRO_OUT, 0) <= -1) return -1;
+	#endif
+		}
 	}
+	return 0;
+}
 
-	if (fcgi->num_pending_writes_to_client > FCGI_PENDING_IO_THRESHOLD)
+static int fcgi_writev_to_client (fcgi_t* fcgi, hio_iovec_t* iov, hio_iolen_t iovcnt)
+{
+	if (fcgi->csck)
 	{
-		/* disable reading on the output stream of the peer */
+		fcgi->ever_attempted_to_write_to_client = 1;
+
+		fcgi->num_pending_writes_to_client++;
+		if (hio_dev_sck_writev(fcgi->csck, iov, iovcnt, HIO_NULL, HIO_NULL) <= -1)
+		{
+			fcgi->num_pending_writes_to_client--;
+			return -1;
+		}
+
 #if 0 // TODO
-		if (hio_dev_pro_read(fcgi->peer, HIO_DEV_PRO_OUT, 0) <= -1) return -1;
+		if (fcgi->num_pending_writes_to_client > FCGI_PENDING_IO_THRESHOLD)
+		{
+			if (hio_dev_pro_read(fcgi->peer, HIO_DEV_PRO_OUT, 0) <= -1) return -1;
+		}
 #endif
 	}
 	return 0;
@@ -229,6 +154,161 @@ static int fcgi_send_final_status_to_client (fcgi_t* fcgi, int status_code, int
 	        (force_close && fcgi_write_to_client(fcgi, HIO_NULL, 0) <= -1))? -1: 0;
 }
 
+static int fcgi_write_last_chunk_to_client (fcgi_t* fcgi)
+{
+	if (!fcgi->ever_attempted_to_write_to_client)
+	{
+		if (fcgi_send_final_status_to_client(fcgi, HIO_HTTP_STATUS_INTERNAL_SERVER_ERROR, 0) <= -1) return -1;
+	}
+	else
+	{
+		if (fcgi->res_mode_to_cli == FCGI_RES_MODE_CHUNKED &&
+		    fcgi_write_to_client(fcgi, "0\r\n\r\n", 5) <= -1) return -1;
+	}
+
+	if (!fcgi->keep_alive && fcgi_write_to_client(fcgi, HIO_NULL, 0) <= -1) return -1;
+	return 0;
+}
+
+#if 0
+static int fcgi_write_to_peer (fcgi_t* fcgi, const void* data, hio_iolen_t dlen)
+{
+	if (fcgi->peer)
+	{
+		fcgi->num_pending_writes_to_peer++;
+		if (hio_svc_fcgic_writestdin(fcgi->peer, data, dlen) <= -1) /* TODO: write STDIN, PARAM? */
+		{
+			fcgi->num_pending_writes_to_peer--;
+			return -1;
+		}
+
+	/* TODO: check if it's already finished or something.. */
+		if (fcgi->num_pending_writes_to_peer > FCGI_PENDING_IO_THRESHOLD)
+		{
+			/* disable input watching */
+			if (hio_dev_sck_read(fcgi->csck, 0) <= -1) return -1;
+		}
+	}
+	return 0;
+}
+#endif
+
+static HIO_INLINE void fcgi_mark_over (fcgi_t* fcgi, int over_bits)
+{
+	hio_svc_htts_t* htts = fcgi->htts;
+	hio_t* hio = htts->hio;
+	unsigned int old_over;
+
+	old_over = fcgi->over;
+	fcgi->over |= over_bits;
+
+	HIO_DEBUG8 (hio, "HTTS(%p) - fcgi(t=%p,c=%p[%d],p=%p) - old_over=%x | new-bits=%x => over=%x\n", fcgi->htts, fcgi, fcgi->client, (fcgi->csck? fcgi->csck->hnd: -1), fcgi->peer, (int)old_over, (int)over_bits, (int)fcgi->over);
+
+	if (!(old_over & FCGI_OVER_READ_FROM_CLIENT) && (fcgi->over & FCGI_OVER_READ_FROM_CLIENT))
+	{
+		if (fcgi->csck && hio_dev_sck_read(fcgi->csck, 0) <= -1)
+		{
+			HIO_DEBUG2 (fcgi->htts->hio, "HTTS(%p) - halting client(%p) for failure to disable input watching\n", fcgi->htts, fcgi->csck);
+			hio_dev_sck_halt (fcgi->csck);
+		}
+	}
+
+	if (!(old_over & FCGI_OVER_READ_FROM_PEER) && (fcgi->over & FCGI_OVER_READ_FROM_PEER))
+	{
+#if 0 // TODO:
+		if (fcgi->peer && hio_dev_pro_read(fcgi->peer, HIO_DEV_PRO_OUT, 0) <= -1)
+		{
+			HIO_DEBUG2 (fcgi->htts->hio, "HTTS(%p) - halting peer(%p) for failure to disable input watching\n", fcgi->htts, fcgi->peer);
+			hio_dev_pro_halt (fcgi->peer);
+		}
+#endif
+	}
+
+	if (old_over != FCGI_OVER_ALL && fcgi->over == FCGI_OVER_ALL)
+	{
+		/* ready to stop */
+#if 0 // TODO:
+		if (fcgi->peer)
+		{
+			HIO_DEBUG2 (fcgi->htts->hio, "HTTS(%p) - halting peer(%p) as it is unneeded\n", fcgi->htts, fcgi->peer);
+			hio_dev_pro_halt (fcgi->peer); // TODO: untie???
+		}
+#endif
+
+		if (fcgi->csck)
+		{
+			if (fcgi->keep_alive && !fcgi->client_eof_detected)
+			{
+				/* how to arrange to delete this fcgi object and put the socket back to the normal waiting state??? */
+				HIO_ASSERT (fcgi->htts->hio, fcgi->client->task == (hio_svc_htts_task_t*)fcgi);
+
+				HIO_SVC_HTTS_TASK_UNREF (fcgi->client->task);
+				/* fcgi must not be accessed from here down as it could have been destroyed */
+			}
+			else
+			{
+				HIO_DEBUG2 (fcgi->htts->hio, "HTTS(%p) - halting client(%p) for no keep-alive\n", fcgi->htts, fcgi->csck);
+				hio_dev_sck_shutdown (fcgi->csck, HIO_DEV_SCK_SHUTDOWN_WRITE);
+				hio_dev_sck_halt (fcgi->csck);
+			}
+		}
+	}
+}
+
+static void fcgi_on_kill (hio_svc_htts_task_t* task)
+{
+	fcgi_t* fcgi = (fcgi_t*)task;
+	hio_t* hio = fcgi->htts->hio;
+
+	HIO_DEBUG2 (hio, "HTTS(%p) - killing fcgi client(%p)\n", fcgi->htts, fcgi->csck);
+
+#if 0
+	if (fcgi->peer)
+	{
+		fcgi_peer_xtn_t* peer = hio_dev_pro_getxtn(fcgi->peer);
+		peer->state = HIO_NULL;  /* peer->state many not be NULL if the resource is killed regardless of the reference count */
+
+		hio_dev_pro_kill (fcgi->peer);
+		fcgi->peer = HIO_NULL;
+	}
+#endif
+
+	if (fcgi->peer_htrd)
+	{
+		fcgi_peer_xtn_t* pxtn = hio_htrd_getxtn(fcgi->peer_htrd);
+		pxtn->fcgi = HIO_NULL; /* peer->fcgi many not be NULL if the resource is killed regardless of the reference count */
+
+		hio_htrd_close (fcgi->peer_htrd);
+		fcgi->peer_htrd = HIO_NULL;
+	}
+
+	if (fcgi->csck)
+	{
+		HIO_ASSERT (hio, fcgi->client != HIO_NULL);
+
+		if (fcgi->client_org_on_read) fcgi->csck->on_read = fcgi->client_org_on_read;
+		if (fcgi->client_org_on_write) fcgi->csck->on_write = fcgi->client_org_on_write;
+		if (fcgi->client_org_on_disconnect) fcgi->csck->on_disconnect = fcgi->client_org_on_disconnect;
+		if (fcgi->client_htrd_recbs_changed) hio_htrd_setrecbs (fcgi->client->htrd, &fcgi->client_htrd_org_recbs);
+
+		if (!fcgi->client_disconnected)
+		{
+			if (!fcgi->keep_alive || hio_dev_sck_read(fcgi->csck, 1) <= -1)
+			{
+				HIO_DEBUG2 (hio, "HTTS(%p) - halting client(%p) for failure to enable input watching\n", fcgi->htts, fcgi->csck);
+				hio_dev_sck_halt (fcgi->csck);
+			}
+		}
+	}
+
+	fcgi->client_org_on_read = HIO_NULL;
+	fcgi->client_org_on_write = HIO_NULL;
+	fcgi->client_org_on_disconnect = HIO_NULL;
+	fcgi->client_htrd_recbs_changed = 0;
+
+	if (fcgi->task_next) HIO_SVC_HTTS_TASKL_UNLINK_TASK (fcgi); /* detach from the htts service only if it's attached */
+}
+
 static int fcgi_client_htrd_poke (hio_htrd_t* htrd, hio_htre_t* req)
 {
 	/* the client request got completed including body.
@@ -268,10 +348,25 @@ static hio_htrd_recbs_t fcgi_client_htrd_recbs =
 static void fcgi_client_on_disconnect (hio_dev_sck_t* sck)
 {
 	hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck);
+	hio_svc_htts_t* htts = cli->htts;
 	fcgi_t* fcgi = (fcgi_t*)cli->task;
+	hio_t* hio = sck->hio;
+
+	HIO_ASSERT (hio, sck == fcgi->csck);
+	HIO_DEBUG4 (hio, "HTTS(%p) - fcgi(t=%p,c=%p,csck=%p) - client socket disconnect handled\n", htts, fcgi, cli, sck);
+
 	fcgi->client_disconnected = 1;
-printf ("client disconnected ............................\n");
-	fcgi->client_org_on_disconnect (sck);
+	fcgi->csck = HIO_NULL;
+	fcgi->client = HIO_NULL;
+	if (fcgi->client_org_on_disconnect)
+	{
+		fcgi->client_org_on_disconnect (sck);
+		/* this original callback destroys the associated resource.
+		 * cgi must not be accessed from here down */
+	}
+
+	HIO_DEBUG4 (hio, "HTTS(%p) - fcgi(t=%p,c=%p,csck=%p) - client socket disconnect handled\n", htts, fcgi, cli, sck);
+	/* Note: after this callback, the actual device pointed to by 'sck' will be freed in the main loop. */
 }
 
 static int fcgi_client_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t len, const hio_skad_t* srcaddr)
@@ -289,24 +384,25 @@ static int fcgi_client_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t
 		goto oops;
 	}
 
-#if 0
 	if (!fcgi->peer)
 	{
 		/* the peer is gone */
 		goto oops; /* do what?  just return 0? */
 	}
-#endif
 
 	if (len == 0)
 	{
 		/* EOF on the client side. arrange to close */
 		HIO_DEBUG3 (hio, "HTTS(%p) - EOF from client %p(hnd=%d)\n", fcgi->htts, sck, (int)sck->hnd);
+		fcgi->client_eof_detected = 1;
 
 		if (!(fcgi->over & FCGI_OVER_READ_FROM_CLIENT)) /* if this is true, EOF is received without fcgi_client_htrd_poke() */
 		{
 			/* indicate eof to the write side */
-			if (hio_svc_fcgic_writestdin(fcgi->peer, HIO_NULL, 0) <= -1) goto oops;
+			int n;
+			n = hio_svc_fcgic_writestdin(fcgi->peer, HIO_NULL, 0);
 			fcgi_mark_over (fcgi, FCGI_OVER_READ_FROM_CLIENT);
+			if (n <= -1) goto oops;
 		}
 	}
 	else
@@ -380,57 +476,222 @@ oops:
 	return 0;
 }
 
-static int fcgi_peer_on_read (hio_svc_fcgic_sess_t* peer, const void* buf, hio_iolen_t len)
+
+static int fcgi_peer_on_read (hio_svc_fcgic_sess_t* peer, const void* data, hio_iolen_t dlen)
 {
-printf ("GOT FCGI DATA.............[%.*s]\n", (int)len, buf);
-	return 0;
-}
-
-static void fcgi_on_kill (hio_svc_htts_task_t* task)
-{
-	fcgi_t* fcgi = (fcgi_t*)task;
-	hio_t* hio = fcgi->htts->hio;
-
-	HIO_DEBUG2 (hio, "HTTS(%p) - killing fcgi client(%p)\n", fcgi->htts, fcgi->csck);
-
-#if 0
-	if (fcgi->peer)
+	fcgi_t* fcgi = hio_svc_fcgic_getsessctx(peer);
+	hio_svc_htts_t* htts = fcgi->htts;
+	hio_t* hio = htts->hio;
+	
+	if (dlen <= -1)
 	{
-		fcgi_peer_xtn_t* peer = hio_dev_pro_getxtn(fcgi->peer);
-		peer->state = HIO_NULL;  /* peer->state many not be NULL if the resource is killed regardless of the reference count */
-
-		hio_dev_pro_kill (fcgi->peer);
-		fcgi->peer = HIO_NULL;
+		HIO_DEBUG2 (hio, "HTTS(%p) - read error from peer %p\n", htts, peer);
+		goto oops;
 	}
-#endif
 
-	if (fcgi->csck)
+	if (dlen == 0)
 	{
-		HIO_ASSERT (hio, fcgi->client != HIO_NULL);
+		HIO_DEBUG2 (hio, "HTTS(%p) - EOF from peer %p\n", htts, peer);
 
-		if (fcgi->client_org_on_read) fcgi->csck->on_read = fcgi->client_org_on_read;
-		if (fcgi->client_org_on_write) fcgi->csck->on_write = fcgi->client_org_on_write;
-		if (fcgi->client_org_on_disconnect) fcgi->csck->on_disconnect = fcgi->client_org_on_disconnect;
-		if (fcgi->client_htrd_recbs_changed) hio_htrd_setrecbs (fcgi->client->htrd, &fcgi->client_htrd_org_recbs);
-
-		if (!fcgi->client_disconnected)
+		if (!(fcgi->over & FCGI_OVER_READ_FROM_PEER))
 		{
-			if (!fcgi->keep_alive || hio_dev_sck_read(fcgi->csck, 1) <= -1)
+			int n;
+			/* the fcgi script could be misbehaving.
+			 * it still has to read more but EOF is read.
+			 * otherwise peer_htrd_poke() should have been called */
+			n = fcgi_write_last_chunk_to_client(fcgi);
+			fcgi_mark_over (fcgi, FCGI_OVER_READ_FROM_PEER);
+			if (n <= -1) goto oops;
+		}
+	}
+	else
+	{
+		hio_oow_t rem;
+
+		HIO_ASSERT (hio, !(fcgi->over & FCGI_OVER_READ_FROM_PEER));
+
+		if (hio_htrd_feed(fcgi->peer_htrd, data, dlen, &rem) <= -1)
+		{
+			HIO_DEBUG2 (hio, "HTTS(%p) - unable to feed peer htrd - peer %p\n", htts, peer);
+
+			if (!fcgi->ever_attempted_to_write_to_client &&
+			    !(fcgi->over & FCGI_OVER_WRITE_TO_CLIENT))
 			{
-				HIO_DEBUG2 (hio, "HTTS(%p) - halting client(%p) for failure to enable input watching\n", fcgi->htts, fcgi->csck);
-				hio_dev_sck_halt (fcgi->csck);
+				fcgi_send_final_status_to_client (fcgi, HIO_HTTP_STATUS_INTERNAL_SERVER_ERROR, 1); /* don't care about error because it jumps to oops below anyway */
 			}
+
+			goto oops;
+		}
+
+		if (rem > 0)
+		{
+			/* If the script specifies Content-Length and produces longer data, it will come here */
+			/* ezcessive data ... */
+			/* TODO: or drop this request?? */
 		}
 	}
 
-	fcgi->client_org_on_read = HIO_NULL;
-	fcgi->client_org_on_write = HIO_NULL;
-	fcgi->client_org_on_disconnect = HIO_NULL;
-	fcgi->client_htrd_recbs_changed = 0;
+	return 0;
 
-	if (fcgi->task_next) HIO_SVC_HTTS_TASKL_UNLINK_TASK (fcgi); /* detach from the htts service only if it's attached */
+oops:
+	fcgi_halt_participating_devices (fcgi); /* TODO: kill the session only??? */
+	return 0;
 }
 
+static int peer_capture_response_header (hio_htre_t* req, const hio_bch_t* key, const hio_htre_hdrval_t* val, void* ctx)
+{
+	hio_svc_htts_cli_t* cli = (hio_svc_htts_cli_t*)ctx;
+
+	/* capture a header except Status, Connection, Transfer-Encoding, and Server */
+	if (hio_comp_bcstr(key, "Status", 1) != 0 &&
+	    hio_comp_bcstr(key, "Connection", 1) != 0 &&
+	    hio_comp_bcstr(key, "Transfer-Encoding", 1) != 0 &&
+	    hio_comp_bcstr(key, "Server", 1) != 0 &&
+	    hio_comp_bcstr(key, "Date", 1) != 0)
+	{
+		do
+		{
+			if (hio_becs_cat(cli->sbuf, key) == (hio_oow_t)-1 ||
+			    hio_becs_cat(cli->sbuf, ": ") == (hio_oow_t)-1 ||
+			    hio_becs_cat(cli->sbuf, val->ptr) == (hio_oow_t)-1 ||
+			    hio_becs_cat(cli->sbuf, "\r\n") == (hio_oow_t)-1)
+			{
+				return -1;
+			}
+
+			val = val->next;
+		}
+		while (val);
+	}
+
+	return 0;
+}
+
+static int peer_htrd_peek (hio_htrd_t* htrd, hio_htre_t* req)
+{
+	fcgi_peer_xtn_t* peer = hio_htrd_getxtn(htrd);
+	fcgi_t* fcgi = peer->fcgi;
+	hio_svc_htts_cli_t* cli = fcgi->client;
+	hio_bch_t dtbuf[64];
+	int status_code = HIO_HTTP_STATUS_OK;
+
+	if (req->attr.content_length)
+	{
+// TOOD: remove content_length if content_length is negative or not numeric.
+		fcgi->res_mode_to_cli = FCGI_RES_MODE_LENGTH;
+	}
+
+	if (req->attr.status)
+	{
+		int is_sober;
+		const hio_bch_t* endptr;
+		hio_intmax_t v;
+
+		v = hio_bchars_to_intmax(req->attr.status, hio_count_bcstr(req->attr.status), HIO_BCHARS_TO_INTMAX_MAKE_OPTION(0,0,0,10), &endptr, &is_sober);
+		if (*endptr == '\0' && is_sober && v > 0 && v <= HIO_TYPE_MAX(int)) status_code = v;
+	}
+
+	hio_svc_htts_fmtgmtime (cli->htts, HIO_NULL, dtbuf, HIO_COUNTOF(dtbuf));
+
+	if (hio_becs_fmt(cli->sbuf, "HTTP/%d.%d %d %hs\r\nServer: %hs\r\nDate: %hs\r\n",
+		fcgi->req_version.major, fcgi->req_version.minor,
+		status_code, hio_http_status_to_bcstr(status_code),
+		cli->htts->server_name, dtbuf) == (hio_oow_t)-1) return -1;
+
+	if (hio_htre_walkheaders(req, peer_capture_response_header, cli) <= -1) return -1;
+
+	switch (fcgi->res_mode_to_cli)
+	{
+		case FCGI_RES_MODE_CHUNKED:
+			if (hio_becs_cat(cli->sbuf, "Transfer-Encoding: chunked\r\n") == (hio_oow_t)-1) return -1;
+			/*if (hio_becs_cat(cli->sbuf, "Connection: keep-alive\r\n") == (hio_oow_t)-1) return -1;*/
+			break;
+
+		case FCGI_RES_MODE_CLOSE:
+			if (hio_becs_cat(cli->sbuf, "Connection: close\r\n") == (hio_oow_t)-1) return -1;
+			break;
+
+		case FCGI_RES_MODE_LENGTH:
+			if (hio_becs_cat(cli->sbuf, (fcgi->keep_alive? "Connection: keep-alive\r\n": "Connection: close\r\n")) == (hio_oow_t)-1) return -1;
+	}
+
+	if (hio_becs_cat(cli->sbuf, "\r\n") == (hio_oow_t)-1) return -1;
+
+	return fcgi_write_to_client(fcgi, HIO_BECS_PTR(cli->sbuf), HIO_BECS_LEN(cli->sbuf));
+}
+
+static int peer_htrd_poke (hio_htrd_t* htrd, hio_htre_t* req)
+{
+	/* client request got completed */
+	fcgi_peer_xtn_t* peer = hio_htrd_getxtn(htrd);
+	fcgi_t* fcgi = peer->fcgi;
+
+	if (fcgi_write_last_chunk_to_client(fcgi) <= -1) return -1;
+
+	fcgi_mark_over (fcgi, FCGI_OVER_READ_FROM_PEER);
+	return 0;
+}
+
+static int peer_htrd_push_content (hio_htrd_t* htrd, hio_htre_t* req, const hio_bch_t* data, hio_oow_t dlen)
+{
+	fcgi_peer_xtn_t* peer = hio_htrd_getxtn(htrd);
+	fcgi_t* fcgi = peer->fcgi;
+
+	HIO_ASSERT (fcgi->htts->hio, htrd == fcgi->peer_htrd);
+
+	switch (fcgi->res_mode_to_cli)
+	{
+		case FCGI_RES_MODE_CHUNKED:
+		{
+			hio_iovec_t iov[3];
+			hio_bch_t lbuf[16];
+			hio_oow_t llen;
+
+			/* hio_fmt_uintmax_to_bcstr() null-terminates the output. only HIO_COUNTOF(lbuf) - 1
+			 * is enough to hold '\r' and '\n' at the back without '\0'. */
+			llen = hio_fmt_uintmax_to_bcstr(lbuf, HIO_COUNTOF(lbuf) - 1, dlen, 16 | HIO_FMT_UINTMAX_UPPERCASE, 0, '\0', HIO_NULL);
+			lbuf[llen++] = '\r';
+			lbuf[llen++] = '\n';
+
+			iov[0].iov_ptr = lbuf;
+			iov[0].iov_len = llen;
+			iov[1].iov_ptr = (void*)data;
+			iov[1].iov_len = dlen;
+			iov[2].iov_ptr = "\r\n";
+			iov[2].iov_len = 2;
+
+			if (fcgi_writev_to_client(fcgi, iov, HIO_COUNTOF(iov)) <= -1) goto oops;
+			break;
+		}
+
+		case FCGI_RES_MODE_CLOSE:
+		case FCGI_RES_MODE_LENGTH:
+			if (fcgi_write_to_client(fcgi, data, dlen) <= -1) goto oops;
+			break;
+	}
+
+#if 0
+	if (fcgi->num_pending_writes_to_client > FCGI_PENDING_IO_THRESHOLD)
+	{
+		if (hio_dev_pro_read(fcgi->peer, HIO_DEV_PRO_OUT, 0) <= -1) goto oops;
+	}
+#endif
+
+	return 0;
+
+oops:
+	return -1;
+}
+
+static hio_htrd_recbs_t peer_htrd_recbs =
+{
+	peer_htrd_peek,
+	peer_htrd_poke,
+	peer_htrd_push_content
+};
+
+
+
 static int write_params (fcgi_t* fcgi, hio_dev_sck_t* csck, hio_htre_t* req, const hio_bch_t* docroot, const hio_bch_t* script)
 {
 	hio_t* hio = fcgi->htts->hio;
@@ -445,7 +706,7 @@ static int write_params (fcgi_t* fcgi, hio_dev_sck_t* csck, hio_htre_t* req, con
 	actual_script = hio_svc_htts_dupmergepaths(fcgi->htts, docroot, script);
 	if (!actual_script) goto oops;
 
-	if (hio_svc_fcgic_writeparam(fcgi->peer, "GATEWAY_INTERFACE", 17, "CGI/1.1", 7) <= -1) goto oops;
+	if (hio_svc_fcgic_writeparam(fcgi->peer, "GATEWAY_INTERFACE", 17, "FCGI/1.1", 7) <= -1) goto oops;
 
 	len = hio_fmttobcstr(hio, tmp, HIO_COUNTOF(tmp), "HTTP/%d.%d", (int)hio_htre_getmajorversion(req), (int)hio_htre_getminorversion(req));
 	if (hio_svc_fcgic_writeparam(fcgi->peer, "SERVER_PROTOCOL", 15, tmp, len) <= -1) goto oops;
@@ -494,12 +755,13 @@ oops:
 	if (actual_script) hio_freemem (hio, actual_script);
 	return -1;
 }
+
 int hio_svc_htts_dofcgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* req, const hio_skad_t* fcgis_addr, const hio_bch_t* docroot, const hio_bch_t* script, int options)
 {
 	hio_t* hio = htts->hio;
 	hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(csck);
 	fcgi_t* fcgi = HIO_NULL;
-	//fcgi_peer_xtn_t* peer_xtn;
+	fcgi_peer_xtn_t* pxtn;
 
 	/* ensure that you call this function before any contents is received */
 	HIO_ASSERT (hio, hio_htre_getcontentlen(req) == 0);
@@ -533,8 +795,15 @@ int hio_svc_htts_dofcgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t*
 	HIO_ASSERT (hio, cli->task == HIO_NULL);
 	HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)fcgi, cli->task); /* cli->task = fcgi */
 
+	fcgi->peer_htrd = hio_htrd_open(hio, HIO_SIZEOF(*pxtn));
+	if (HIO_UNLIKELY(!fcgi->peer_htrd)) goto oops;
+	hio_htrd_setoption (fcgi->peer_htrd, HIO_HTRD_SKIP_INITIAL_LINE | HIO_HTRD_RESPONSE);
+	hio_htrd_setrecbs (fcgi->peer_htrd, &peer_htrd_recbs);
+	pxtn = hio_htrd_getxtn(fcgi->peer_htrd);
+	HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)fcgi, pxtn->fcgi); /* peer->fcgi in htrd = fcgi */
+
 	/* create a session in in the fcgi client service */
-	fcgi->peer = hio_svc_fcgic_tie(htts->fcgic, fcgis_addr, fcgi_peer_on_read);
+	fcgi->peer = hio_svc_fcgic_tie(htts->fcgic, fcgis_addr, fcgi_peer_on_read, fcgi);
 	if (HIO_UNLIKELY(!fcgi->peer)) goto oops;
 
 	/* send FCGI_BEGIN_REQUEST */
@@ -552,15 +821,15 @@ int hio_svc_htts_dofcgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t*
 		 * option 2. send 411 Length Required immediately
 		 * option 3. set Content-Length to -1 and use EOF to indicate the end of content [Non-Standard] */
 
-		if (cgi_send_final_status_to_client(cgi, HIO_HTTP_STATUS_LENGTH_REQUIRED, 1) <= -1) goto oops;
+		if (fcgi_send_final_status_to_client(fcgi, HIO_HTTP_STATUS_LENGTH_REQUIRED, 1) <= -1) goto oops;
 	}
 #endif
 
 	if (req->flags & HIO_HTRE_ATTR_EXPECT100)
 	{
 		/* TODO: Expect: 100-continue? who should handle this? fcgi? or the http server? */
-		/* CAN I LET the cgi SCRIPT handle this? */
-		if (!(options & HIO_SVC_HTTS_CGI_NO_100_CONTINUE) &&
+		/* CAN I LET the fcgi SCRIPT handle this? */
+		if (!(options & HIO_SVC_HTTS_FCGI_NO_100_CONTINUE) &&
 		    hio_comp_http_version_numbers(&req->version, 1, 1) >= 0 &&
 		   (fcgi->req_content_length_unlimited || fcgi->req_content_length > 0))
 		{
@@ -623,12 +892,12 @@ int hio_svc_htts_dofcgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t*
 	}
 #endif
 
-	/* this may change later if Content-Length is included in the cgi output */
+	/* this may change later if Content-Length is included in the fcgi output */
 	if (req->flags & HIO_HTRE_ATTR_KEEPALIVE)
 	{
 		fcgi->keep_alive = 1;
 		fcgi->res_mode_to_cli = FCGI_RES_MODE_CHUNKED;
-		/* the mode still can get switched to FCGI_RES_MODE_LENGTH if the cgi script emits Content-Length */
+		/* the mode still can get switched to FCGI_RES_MODE_LENGTH if the fcgi script emits Content-Length */
 	}
 	else
 	{
@@ -636,7 +905,7 @@ int hio_svc_htts_dofcgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t*
 		fcgi->res_mode_to_cli = FCGI_RES_MODE_CLOSE;
 	}
 
-	/* TODO: store current input watching state and use it when destroying the cgi data */
+	/* TODO: store current input watching state and use it when destroying the fcgi data */
 	if (hio_dev_sck_read(csck, !(fcgi->over & FCGI_OVER_READ_FROM_CLIENT)) <= -1) goto oops;
 
 	HIO_SVC_HTTS_TASKL_APPEND_TASK (&htts->task, fcgi);
diff --git a/lib/http-file.c b/lib/http-file.c
index 4e80b70..55f1d08 100644
--- a/lib/http-file.c
+++ b/lib/http-file.c
@@ -98,7 +98,7 @@ static int file_send_contents_to_client (file_t* file);
 static void file_halt_participating_devices (file_t* file)
 {
 	HIO_ASSERT (file->htts->hio, file->client != HIO_NULL);
-	HIO_ASSERT (file->htts->hio, file->client->sck != HIO_NULL);
+	HIO_ASSERT (file->htts->hio, file->csck != HIO_NULL);
 
 	HIO_DEBUG3 (file->htts->hio, "HTTS(%p) - file(c=%d,p=%d) Halting participating devices\n", file->htts, (int)file->csck->hnd, (int)file->peer);
 
@@ -331,7 +331,6 @@ static void file_client_on_disconnect (hio_dev_sck_t* sck)
 	hio_svc_htts_t* htts = file->htts;
 
 	HIO_ASSERT (hio, sck == cli->sck);
-	HIO_ASSERT (hio, sck == file->client->sck);
 	HIO_ASSERT (hio, sck == file->csck);
 
 	HIO_DEBUG4 (hio, "HTTS(%p) - file(t=%p,c=%p,csck=%p) - client socket disconnect notified\n", htts, file, sck, cli);
@@ -357,7 +356,6 @@ static int file_client_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t
 	file_t* file = (file_t*)cli->task;
 
 	HIO_ASSERT (hio, sck == cli->sck);
-	HIO_ASSERT (hio, sck == file->client->sck);
 	HIO_ASSERT (hio, sck == file->csck);
 
 	if (len <= -1)
@@ -417,7 +415,6 @@ static int file_client_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wr
 	file_t* file = (file_t*)cli->task;
 
 	HIO_ASSERT (hio, sck == cli->sck);
-	HIO_ASSERT (hio, sck == file->client->sck);
 	HIO_ASSERT (hio, sck == file->csck);
 
 	if (wrlen <= -1)