@@ -143,7 +143,7 @@ DEFS+= -DNAME='"$(NAME)"' -DVERSION='"$(RELEASE)"' -DARCH='"$(ARCH)"' \

 	 -DDNS_IP_HACK \

 	 -DUSE_IPV6 \

 	 -DDBG_QM_MALLOC \

-	# -DUSE_TCP \

+	 #-DUSE_TCP \

 	 #-DF_MALLOC \

 	 #-DNO_DEBUG \

 	 #-DNO_LOG

@@ -33,8 +33,14 @@

 #define TCP_BUF_SIZE 65535

-enum {TCP_REQ_INIT, TCP_REQ_OK, TCP_READ_ERROR, TCP_REQ_OVERRUN };

-enum {H_PARSING, H_LF, H_LFCR,  H_BODY };

+enum {	TCP_REQ_INIT, TCP_REQ_OK, TCP_READ_ERROR, TCP_REQ_OVERRUN, 

+	 	TCP_REQ_BAD_LEN };

+enum {	H_SKIP, H_LF, H_LFCR,  H_BODY, H_STARTWS,

+		H_CONT_LEN1, H_CONT_LEN2, H_CONT_LEN3, H_CONT_LEN4, H_CONT_LEN5,

+		H_CONT_LEN6, H_CONT_LEN7, H_CONT_LEN8, H_CONT_LEN9, H_CONT_LEN10,

+		H_CONT_LEN11, H_CONT_LEN12, H_CONT_LEN13, H_L_COLON, 

+		H_CONT_LEN_BODY, H_CONT_LEN_BODY_PARSE 

+	};

 struct tcp_req{

 	struct tcp_req* next;

@@ -44,6 +50,10 @@ struct tcp_req{

 	char* pos; /* current position in buf */

 	char* parsed; /* last parsed position */

 	char* body; /* body position */

+	int content_len;

+	int has_content_len; /* 1 if content_length was parsed ok*/

+	int complete; /* 1 if one req has been fully read, 0 otherwise*/

+	int bytes_to_go; /* how many bytes we have still to read from the body*/

 	int error;

 	int state;

 };

@@ -55,7 +65,7 @@ struct tcp_req{

 		(r)->fd=(f); \

 		(r)->parsed=(r)->pos=(r)->buf; \

 		(r)->error=TCP_REQ_OK;\

-		(r)->state=H_PARSING; \

+		(r)->state=H_STARTWS; \

 	}while(0)

@@ -193,6 +193,7 @@ void tcp_main_loop()

 	struct tcp_connection* tcpconn;

 	long response[2];

 	int state;

+	int bytes;

 	socklen_t su_len;

 	/*init */

@@ -271,8 +272,23 @@ void tcp_main_loop()

 		for (r=0; r<tcp_children_no && n; r++){

 			if (FD_ISSET(tcp_children[r].s, &sel_set)){

 				n--;

-				/* errno==EINTR !!! todo*/

-				read(tcp_children[r].s, response, sizeof(response));

+				/* errno==EINTR !!! TODO*/

+read_again:

+				bytes=read(tcp_children[r].s, response, sizeof(response));

+				if (bytes==0){

+					/* EOF -> bad, chidl has died */

+					LOG(L_CRIT, "BUG: tcp_main_loop: dead child %d\n", r);

+					/* terminating everybody */

+					exit(-1);

+				}else if (bytes<0){

+					if (errno==EINTR) goto read_again;

+					else{

+						LOG(L_CRIT, "ERROR: tcp_main_loop: read from child: "

+								" %s\n", strerror(errno));

+						/* try to continue ? */

+					}

+				}

+					

 				DBG("tcp__main_loop: read response= %lx, %ld\n",

 						response[0], response[1]);

 				tcp_children[r].busy=0;

@@ -40,8 +40,11 @@

 #include <unistd.h>

+#include "dprint.h"

 #include "tcp_conn.h"

 #include "pass_fd.h"

+#include "globals.h"

+#include "receive.h"

 #define q_memchr memchr

@@ -80,24 +83,76 @@ again:

-/* reads all headers (until double crlf),

+/* reads all headers (until double crlf), & parses the content-length header

+ * (WARNING: highly ineficient, tries to reuse receive_msg but will parse

+ *  all the header names twice [once here & once in receive_msg]; a more

+ *  speed eficient version will result in either major code duplication or

+ *  major changes to the receive code - TODO)

  * returns number of bytes read & sets r->state & r->body

  * when either r->body!=0 or r->state==H_BODY =>

  * all headers have been read. It should be called in a while loop.

  * returns < 0 if error or 0 if EOF */

 int tcp_read_headers(struct tcp_req *r)

 {

-	int bytes;

+	int bytes, remaining;

 	char *p;

+	#define crlf_default_skip_case \

+					case '\n': \

+						r->state=H_LF; \

+						break; \

+					default: \

+						r->state=H_SKIP

+	

+	#define content_len_beg_case \

+					case ' ': \

+					case '\t': \

+						if (!r->has_content_len) r->state=H_STARTWS; \

+						else r->state=H_SKIP; \

+							/* not interested if we already found one */ \

+						break; \

+					case 'C': \

+					case 'c': \

+						if(!r->has_content_len) r->state=H_CONT_LEN1; \

+						else r->state=H_SKIP; \

+						break 

+						

+	#define change_state(upper, lower, newstate)\

+					switch(*p){ \

+						case upper: \

+						case lower: \

+							r->state=(newstate); break; \

+						crlf_default_skip_case; \

+					}

+	

+	#define change_state_case(state0, upper, lower, newstate)\

+					case state0: \

+							  change_state(upper, lower, newstate); \

+							  p++; \

+							  break

+

+

+	

 	bytes=tcp_read(r);

 	if (bytes<=0) return bytes;

 	p=r->parsed;

-	while(p<r->pos && r->state!=H_BODY){

+	while(p<r->pos && r->error==TCP_REQ_OK){

 		switch(r->state){

-			case H_PARSING:

-				/* find lf */

+			case H_BODY: /* read the body*/

+				remaining=r->pos-p;

+				if (remaining>r->bytes_to_go) remaining=r->bytes_to_go;

+				r->bytes_to_go-=remaining;

+				p+=remaining;

+				if (r->bytes_to_go==0){

+					r->complete=1;

+					goto skip;

+				}

+				break;

+				

+			case H_SKIP:

+				/* find lf, we are in this state if we are not interested

+				 * in anything till end of line*/

 				p=q_memchr(p, '\n', r->pos-r->parsed);

 				if (p){

 					p++;

@@ -109,31 +164,146 @@ int tcp_read_headers(struct tcp_req *r)

 			case H_LF:

 				/* terminate on LF CR LF or LF LF */

-				if (*p=='\r'){

-					r->state=H_LFCR;

-				}else if (*p=='\n'){

-					/* found LF LF */

-					r->state=H_BODY;

-					r->body=p+1;

-				}else r->state=H_PARSING;

+				switch (*p){

+					case '\r':

+						r->state=H_LFCR;

+						break;

+					case '\n':

+						/* found LF LF */

+						r->state=H_BODY;

+						if (r->has_content_len){

+							r->body=p+1;

+							r->bytes_to_go=r->content_len;

+							if (r->bytes_to_go==0){

+								r->complete=1;

+								goto skip;

+							}

+						}else{

+							r->error=TCP_REQ_BAD_LEN;

+						}

+						break;

+					content_len_beg_case;

+					default: 

+						r->state=H_SKIP;

+				}

 				p++;

 				break;

-			

 			case H_LFCR:

 				if (*p=='\n'){

 					/* found LF CR LF */

 					r->state=H_BODY;

-					r->body=p+1;

-				}else r->state=H_PARSING;

+					if (r->has_content_len){

+						r->body=p+1;

+						r->bytes_to_go=r->content_len;

+						if (r->bytes_to_go==0){

+							r->complete=1;

+							goto skip;

+						}

+					}else{

+						r->error=TCP_REQ_BAD_LEN;

+					}

+				}else r->state=H_SKIP;

 				p++;

 				break;

+			case H_STARTWS:

+				switch (*p){

+					content_len_beg_case;

+					crlf_default_skip_case;

+				}

+				p++;

+				break;

+			

+			change_state_case(H_CONT_LEN1,  'O', 'o', H_CONT_LEN2);

+			change_state_case(H_CONT_LEN2,  'N', 'n', H_CONT_LEN3);

+			change_state_case(H_CONT_LEN3,  'T', 't', H_CONT_LEN4);

+			change_state_case(H_CONT_LEN4,  'E', 'e', H_CONT_LEN5);

+			change_state_case(H_CONT_LEN5,  'N', 'n', H_CONT_LEN6);

+			change_state_case(H_CONT_LEN6,  'T', 't', H_CONT_LEN7);

+			change_state_case(H_CONT_LEN7,  '-', '_', H_CONT_LEN8);

+			change_state_case(H_CONT_LEN8,  'L', 'l', H_CONT_LEN9);

+			change_state_case(H_CONT_LEN9,  'E', 'e', H_CONT_LEN10);

+			change_state_case(H_CONT_LEN10, 'N', 'n', H_CONT_LEN11);

+			change_state_case(H_CONT_LEN11, 'G', 'g', H_CONT_LEN12);

+			change_state_case(H_CONT_LEN12, 'T', 't', H_CONT_LEN13);

+			change_state_case(H_CONT_LEN13, 'H', 'h', H_L_COLON);

+			

+			case H_L_COLON:

+				switch(*p){

+					case ' ':

+					case '\t':

+						break; /* skip space */

+					case ':':

+						r->state=H_CONT_LEN_BODY;

+						break;

+					crlf_default_skip_case;

+				};

+				p++;

+				break;

+			

+			case  H_CONT_LEN_BODY:

+				switch(*p){

+					case ' ':

+					case '\t':

+						break; /* eat space */

+					case '0':

+					case '1':

+					case '2':

+					case '3':

+					case '4':

+					case '5':

+					case '6':

+					case '7':

+					case '8':

+					case '9':

+						r->state=H_CONT_LEN_BODY_PARSE;

+						r->content_len=(*p-'0');

+						break;

+					/*FIXME: content lenght on different lines ! */

+					crlf_default_skip_case;

+				}

+				p++;

+				break;

+				

+			case H_CONT_LEN_BODY_PARSE:

+				switch(*p){

+					case '0':

+					case '1':

+					case '2':

+					case '3':

+					case '4':

+					case '5':

+					case '6':

+					case '7':

+					case '8':

+						r->content_len=r->content_len*10+(*p-'0');

+						break;

+					case '\r':

+					case ' ':

+					case '\t': /* FIXME: check if line contains only WS */

+						r->state=H_SKIP;

+						r->has_content_len=1;

+						break;

+					case '\n':

+						/* end of line, parse succesfull */

+						r->state=H_LF;

+						r->has_content_len=1;

+						break;

+					default:

+						LOG(L_ERR, "ERROR: tcp_read_headers: bad "

+								"Content-Length header value, unexpected "

+								"char %c in state %d\n", *p, r->state);

+						r->state=H_SKIP; /* try to find another?*/

+				}

+				p++;

+				break;

+			

 			default:

 				fprintf(stderr, "BUG: unexpected state %d\n", r->state);

 				abort();

 		}

 	}

-	

+skip:

 	r->parsed=p;

 	return bytes;

 }

@@ -184,7 +354,7 @@ void tcp_receive_loop(int unix_sock)

 	again:

-		while(req.body==0){

+		while(req.complete==0 && req.error==TCP_REQ_OK){

 			bytes=tcp_read_headers(&req);

 			/* if timeout state=0; goto end__req; */

 			fprintf(stderr, "read= %d bytes, parsed=%d, state=%d, error=%d\n",

@@ -201,17 +371,31 @@ void tcp_receive_loop(int unix_sock)

 			}

 		}

+		if (req.error!=TCP_REQ_OK){

+			fprintf(stderr, "bad request, state=%d, error=%d\n",

+					req.state, req.error);

+			state=-1;

+			goto end_req;

+		}

 		fprintf(stderr, "end of header part\n");

 		fprintf(stderr, "headers:\n%.*s.\n",req.body-req.buf, req.buf);

+		if (req.has_content_len){

+			fprintf(stderr, "content-length= %d\n", req.content_len);

+			fprintf(stderr, "body:\n%.*s\n", req.content_len, req.body);

+		}else{

+			req.error=TCP_REQ_BAD_LEN;

+			fprintf(stderr, "content length not present or unparsable\n");

+			state=-1;

+			goto end_req;

+		}

-		/* just debugging*/

+		/* if we are here everything is nice and ok*/

 		state=0;

-		goto end_req;

-		/* parse headers ... */

-		

-		/* get body */

-		

-		/* copy request */

+		/* just for debugging use sendipv4 as receiving socket */

+		DBG("calling receive_msg(%p, %d, %p)\n",

+				req.buf, (int)(req.parsed-req.buf), &sendipv4->su);

+		bind_address=sendipv4;

+		receive_msg(req.buf, req.parsed-req.buf, &sendipv4->su);

 		/* prepare for next request */

 		size=req.pos-req.body;

@@ -221,7 +405,9 @@ void tcp_receive_loop(int unix_sock)

 		req.parsed=req.buf;

 		req.body=0;

 		req.error=TCP_REQ_OK;

-		req.state=H_PARSING;

+		req.state=H_STARTWS;

+		req.complete=req.content_len=req.has_content_len=0;

+		req.bytes_to_go=0;

 		/* process last req. */