now the separated http worker works. Changed some size_t to ssize_t as i use -1 …

…and -2 es error indicator in my server and fixed caculation of remainig buffer size in reader

+2012-02-15 12:17:00 +0100 Georg Hopp 
+
+	* now the separated http worker works. Changed some size_t to ssize_t as i use -1 and -2 es error indicator in my server and fixed caculation of remainig buffer size in reader (HEAD, master)
+
 2012-02-15 09:38:32 +0100 Georg Hopp 
 2012-02-15 09:38:32 +0100 Georg Hopp 
 
 
-	* separated the server completely from the http processing (HEAD, master)
+	* separated the server completely from the http processing
 
 
 2012-02-15 06:19:52 +0100 Georg Hopp 
 2012-02-15 06:19:52 +0100 Georg Hopp 
 
 

@@ -33,12 +33,12 @@ CLASS(HttpRequestParser) {
 	HttpRequestState state;
 	HttpRequestState state;
 };
 };
 
 
-size_t httpRequestParserRead(HttpRequestParser, int);
-size_t httpRequestParserParse(HttpRequestParser);
-void   httpRequestParserGetBody(HttpRequestParser);
+ssize_t httpRequestParserRead(HttpRequestParser, int);
+ssize_t httpRequestParserParse(HttpRequestParser);
+void    httpRequestParserGetBody(HttpRequestParser);
 
 
-void   httpRequestParserGetRequestLine(HttpRequest, char *);
-void   httpRequestParserGetHeader(HttpRequest, char *);
+void    httpRequestParserGetRequestLine(HttpRequest, char *);
+void    httpRequestParserGetHeader(HttpRequest, char *);
 
 
 #endif /* __HTTP_REQUEST_PARSER_H__ */
 #endif /* __HTTP_REQUEST_PARSER_H__ */
 
 

@@ -29,7 +29,7 @@ CLASS(HttpResponseWriter) {
 	HttpResponseState state;
 	HttpResponseState state;
 };
 };
 
 
-size_t httpResponseWriterWrite(HttpResponseWriter, int);
+ssize_t httpResponseWriterWrite(HttpResponseWriter, int);
 
 
 #endif // __HTTP_RESPONSE_WRITER_H__
 #endif // __HTTP_RESPONSE_WRITER_H__
 
 

@@ -12,8 +12,8 @@ CLASS(HttpWorker) {
 	HttpResponseWriter writer;
 	HttpResponseWriter writer;
 };
 };
 
 
-size_t httpWorkerProcess(HttpWorker, int);
-size_t httpWorkerWrite(HttpWorker, int);
+ssize_t httpWorkerProcess(HttpWorker, int);
+ssize_t httpWorkerWrite(HttpWorker, int);
 
 
 #endif // __HTTP_WORKER_H__
 #endif // __HTTP_WORKER_H__
 
 

@@ -3,7 +3,7 @@
 
 
 #include <sys/types.h>
 #include <sys/types.h>
 
 
-typedef size_t (* fptr_streamReaderRead)(void *, int fd);
+typedef ssize_t (* fptr_streamReaderRead)(void *, int fd);
 
 
 extern const struct interface i_StreamReader;
 extern const struct interface i_StreamReader;
 
 
@@ -12,7 +12,7 @@ struct i_StreamReader {
 	fptr_streamReaderRead          read;
 	fptr_streamReaderRead          read;
 };
 };
 
 
-extern size_t streamReaderRead(void *, int fd);
+extern ssize_t streamReaderRead(void *, int fd);
 
 
 #endif // __STREAM_READER_H__
 #endif // __STREAM_READER_H__
 
 

@@ -3,7 +3,7 @@
 
 
 #include <sys/types.h>
 #include <sys/types.h>
 
 
-typedef size_t (* fptr_streamWriterWrite)(void *, int fd);
+typedef ssize_t (* fptr_streamWriterWrite)(void *, int fd);
 
 
 extern const struct interface i_StreamWriter;
 extern const struct interface i_StreamWriter;
 
 
@@ -12,7 +12,7 @@ struct i_StreamWriter {
 	fptr_streamWriterWrite         write;
 	fptr_streamWriterWrite         write;
 };
 };
 
 
-extern size_t streamWriterWrite(void *, int fd);
+extern ssize_t streamWriterWrite(void *, int fd);
 
 
 #endif // __STREAM_WRITER_H__
 #endif // __STREAM_WRITER_H__
 
 

@@ -33,11 +33,12 @@ httpRequestSkip(char ** data)
 	for (; 0 != **data && ! isalpha(**data); (*data)++);
 	for (; 0 != **data && ! isalpha(**data); (*data)++);
 }
 }
 
 
-size_t
+ssize_t
 httpRequestParserParse(HttpRequestParser this)
 httpRequestParserParse(HttpRequestParser this)
 {
 {
-	char * line;
-	int    cont = 1;
+	char *  line;
+	int     cont = 1;
+	ssize_t ret  = this->request_queue->nmsgs;
 
 
 	while (cont) {
 	while (cont) {
 		switch(this->state) {
 		switch(this->state) {
@@ -84,6 +85,11 @@ httpRequestParserParse(HttpRequestParser this)
 				 */
 				 */
 				this->request_queue->msgs[(this->request_queue->nmsgs)++] =
 				this->request_queue->msgs[(this->request_queue->nmsgs)++] =
 					(HttpMessage)this->cur_request;
 					(HttpMessage)this->cur_request;
+
+				if (! httpMessageHasKeepAlive((HttpMessage)this->cur_request)) {
+					ret = -2;
+				}
+
 				this->cur_request = NULL;
 				this->cur_request = NULL;
 
 
 				/**
 				/**

@@ -4,16 +4,17 @@
 #include "http/request/parser.h"
 #include "http/request/parser.h"
 
 
 
 
-size_t
+ssize_t
 httpRequestParserRead(HttpRequestParser this, int fd)
 httpRequestParserRead(HttpRequestParser this, int fd)
 {
 {
 	size_t remaining, chunks;
 	size_t remaining, chunks;
 	char   buffer[1024];
 	char   buffer[1024];
 
 
-	size_t size = read(fd, buffer, 1024);
+	ssize_t size = read(fd, buffer, 1024);
 
 
 	if (0 < size) {
 	if (0 < size) {
 		remaining = this->buffer_used % HTTP_REQUEST_PARSER_READ_CHUNK;
 		remaining = this->buffer_used % HTTP_REQUEST_PARSER_READ_CHUNK;
+		remaining = HTTP_REQUEST_PARSER_READ_CHUNK - remaining;
 		chunks    = this->buffer_used / HTTP_REQUEST_PARSER_READ_CHUNK;
 		chunks    = this->buffer_used / HTTP_REQUEST_PARSER_READ_CHUNK;
 
 
 		/**
 		/**
@@ -37,6 +38,9 @@ httpRequestParserRead(HttpRequestParser this, int fd)
 
 
 		size = httpRequestParserParse(this);
 		size = httpRequestParserParse(this);
 	}
 	}
+	else {
+		size = (0 == size)? -2 : size;
+	}
 
 
 	return size;
 	return size;
 }
 }

@@ -16,12 +16,12 @@
 #define _PSIZE(x)	(MAX((x),RESPONSE_WRITER_MAX_BUF))
 #define _PSIZE(x)	(MAX((x),RESPONSE_WRITER_MAX_BUF))
 #define PSIZE		_PSIZE(this->nheader+message->nbody)
 #define PSIZE		_PSIZE(this->nheader+message->nbody)
 
 
-size_t
+ssize_t
 httpResponseWriterWrite(HttpResponseWriter this, int fd)
 httpResponseWriterWrite(HttpResponseWriter this, int fd)
 {
 {
 	HttpMessageQueue respq     = this->response_queue;
 	HttpMessageQueue respq     = this->response_queue;
 	HttpMessage      message   = (HttpMessage)this->cur_response;
 	HttpMessage      message   = (HttpMessage)this->cur_response;
-	size_t           processed = (message)? 1 : 0;
+	ssize_t           processed = (message)? 1 : 0;
 	int              cont      = 1;
 	int              cont      = 1;
 
 
 	while (cont) {
 	while (cont) {

@@ -4,10 +4,10 @@
 #include "http/worker.h"
 #include "http/worker.h"
 #include "http/request/parser.h"
 #include "http/request/parser.h"
 
 
-size_t
+ssize_t
 httpWorkerProcess(HttpWorker this, int fd)
 httpWorkerProcess(HttpWorker this, int fd)
 {
 {
-	size_t size;
+	ssize_t size;
 
 
 	if (0 < (size = httpRequestParserRead(this->parser, fd))) {
 	if (0 < (size = httpRequestParserRead(this->parser, fd))) {
 		int              i;
 		int              i;

@@ -3,7 +3,7 @@
 #include "http/worker.h"
 #include "http/worker.h"
 #include "http/response/writer.h"
 #include "http/response/writer.h"
 
 
-size_t
+ssize_t
 httpWorkerWrite(HttpWorker this, int fd)
 httpWorkerWrite(HttpWorker this, int fd)
 {
 {
 	return httpResponseWriterWrite(this->writer, fd);
 	return httpResponseWriterWrite(this->writer, fd);

@@ -6,10 +6,10 @@ const struct interface i_StreamReader = {
 	1
 	1
 };
 };
 
 
-size_t
+ssize_t
 streamReaderRead(void * object, int fd)
 streamReaderRead(void * object, int fd)
 {
 {
-	size_t ret;
+	ssize_t ret;
 
 
 	RETCALL(object, StreamReader, read, ret, fd);
 	RETCALL(object, StreamReader, read, ret, fd);
 
 

@@ -6,10 +6,10 @@ const struct interface i_StreamWriter = {
 	1
 	1
 };
 };
 
 
-size_t
+ssize_t
 streamWriterWrite(void * object, int fd)
 streamWriterWrite(void * object, int fd)
 {
 {
-	size_t ret;
+	ssize_t ret;
 
 
 	RETCALL(object, StreamWriter, write, ret, fd);
 	RETCALL(object, StreamWriter, write, ret, fd);
 
 

 static
 static
-int
+ssize_t
 serverRead(Server this, unsigned int i)
 serverRead(Server this, unsigned int i)
 {
 {
-	int fd = (this->fds)[i].fd;
-	int size;
+	int     fd = (this->fds)[i].fd;
+	ssize_t size;
 
 
 	if (NULL == (this->conns)[fd].worker) {
 	if (NULL == (this->conns)[fd].worker) {
 		loggerLog(
 		loggerLog(
@@ -14,10 +14,12 @@ serverRead(Server this, unsigned int i)
 	}
 	}
 
 
 	switch ((size = streamReaderRead((this->conns)[fd].worker, fd))) {
 	switch ((size = streamReaderRead((this->conns)[fd].worker, fd))) {
-		case 0:
+		case -2:
 			/*
 			/*
-			 * normal close: write remaining data
-			 * @TODO: actually we have no remaining data here....
+			 * normal close: this must be mapped to -2 within the
+			 * underlying read call. Done now in httpRequestParserRead
+			 * @TODO: make sure all pending writes will be done before
+			 * close.
 			 */
 			 */
 			/* DROP-THROUGH */
 			/* DROP-THROUGH */
 
 

@@ -88,6 +88,7 @@ serverRun(Server this)
 					nreads--;
 					nreads--;
 
 
 					switch (serverRead(this, i)) {
 					switch (serverRead(this, i)) {
+						case -2:
 						case -1:
 						case -1:
 							serverCloseConn(this, i);
 							serverCloseConn(this, i);
 							break;
 							break;