now each HttpRequestParser initializes its own request queue and enqueus completed requests there. The server now gets the queue and prints completed requests.

ChangeLog

@@ -1,6 +1,30 @@
+2012-02-07 13:41:49 +0100 Georg Hopp 
+
+	* now each HttpRequestParser initializes its own request queue and enqueus completed requests there. The server now gets the queue and prints completed requests. (HEAD, master)
+
+2012-02-07 11:12:30 +0100 Georg Hopp 
+
+	* started filling out a request object with the parser
+
+2012-02-07 09:29:59 +0100 Georg Hopp 
+
+	* porformance improvement in parsing process (no longer do alloc and free on each line)
+
+2012-02-07 08:52:18 +0100 Georg Hopp 
+
+	* basic request parsing (line by line) implemented
+
+2012-02-06 16:08:13 +0100 Georg Hopp 
+
+	* split server implementation for readability
+
+2012-02-06 11:35:40 +0100 Georg Hopp 
+
+	* free reader (HttpRequestParser) when connection is closed
+
 2012-02-06 11:20:00 +0100 Georg Hopp 
 
-	* add StreamReader interface, modify HttpRequestParser and Server to use it (HEAD, master)
+	* add StreamReader interface, modify HttpRequestParser and Server to use it
 
 2012-02-06 11:15:00 +0100 Georg Hopp 
 

include/http/request_parser.h

@@ -2,8 +2,7 @@
 #define __HTTP_REQUEST_PARSER_H__
 
 #include "class.h"
-//#include "http/request.h"
-//#include "http/request_queue.h"
+#include "http/request_queue.h"
 
 #define HTTP_REQUEST_PARSER_READ_CHUNK	1024
 
@@ -21,7 +20,7 @@ CLASS(HttpRequestParser) {
 	size_t           buffer_used;
 	size_t           buffer_size;
 
-	//HttpRequestQueue request_queue;
+	HttpRequestQueue request_queue;
 	HttpRequestState state;
 };
 

include/http/request_queue.h

@@ -9,8 +9,8 @@
 
 CLASS(HttpRequestQueue) {
 	HttpRequest requests[HTTP_REQUEST_QUEUE_MAX];
-	size_t  nrequests;
-}
+	size_t      nrequests;
+};
 
 #endif /* __HTTP_REQUEST_QUEUE_H__ */
 

src/Makefile.am

@@ -5,7 +5,7 @@ CLASS  = class.c interface.c interface/class.c
 SOCKET = socket.c socket/accept.c socket/connect.c socket/listen.c
 SERVER = server.c server/run.c server/close_conn.c
 LOGGER = logger.c logger/stderr.c logger/syslog.c interface/logger.c
-HTTP   = interface/stream_reader.c http/request_parser.c http/request.c
+HTTP   = interface/stream_reader.c http/request_parser.c http/request.c http/request_queue.c
 
 AM_CFLAGS = -Wall -I ../include/
 

src/http/request.c

@@ -2,9 +2,10 @@
 #include <stdarg.h>
 
 #include "class.h"
-#include "http/request.h"
 #include "interface/class.h"
 
+#include "http/request.h"
+
 static
 void
 _free(void ** data)

src/http/request_parser.c

@@ -11,7 +11,7 @@
 #include "interface/class.h"
 #include "interface/stream_reader.h"
 #include "http/request.h"
-//#include "http/request_queue.h"
+#include "http/request_queue.h"
 
 static
 void
@@ -23,7 +23,7 @@ ctor(void * _this, va_list * params)
 {
 	HttpRequestParser this = _this;
 
-	//this->request_queue = va_arg(*params, HttpRequestQueue);
+	this->request_queue = new(HttpRequestQueue);
 
 	this->buffer = malloc(HTTP_REQUEST_PARSER_READ_CHUNK);
 	this->buffer[0] = 0;
@@ -36,6 +36,7 @@ dtor(void * _this)
 	HttpRequestParser this = _this;
 
 	free(this->buffer);
+	delete(&(this->request_queue));
 } 
 
 static
@@ -46,7 +47,10 @@ _clone(void * _this, void * _base)
 	HttpRequestParser base = _base;
 	size_t            chunks;
 
-	//this->request_queue = base->request_queue;
+	/**
+	 * every parser has its own queue...
+	 */
+	this->request_queue = new(HttpRequestQueue);
 	this->buffer_used   = base->buffer_used;
 
 	chunks = this->buffer_used / HTTP_REQUEST_PARSER_READ_CHUNK;
@@ -183,10 +187,6 @@ httpRequestParserParse(HttpRequestParser this)
 					}
 				}
 
-				printf("method: %s\n", request->method);
-				printf("uri: %s\n", request->uri);
-				printf("version: %s\n", request->http_version);
-
 				header_idx = 0;
 				this->state = HTTP_REQUEST_REQEUST_LINE_DONE;
 				break;
@@ -223,16 +223,6 @@ httpRequestParserParse(HttpRequestParser this)
 			case HTTP_REQUEST_HEADERS_DONE:
 				puts("==headers done==");
 
-				{
-					int i;
-
-					for (i=0; i<header_idx; i++) {
-						printf("header-name:  %s\n", (request->header)[i].name);
-						printf("header-value: %s\n", (request->header)[i].value);
-					}
-				}
-
-				printf("%s\n", line);
 				this->state = HTTP_REQUEST_DONE;
 				break;
 
@@ -249,7 +239,9 @@ httpRequestParserParse(HttpRequestParser this)
 					cont = 0;
 				}
 
-				delete(&request);
+				this->request_queue->requests[(this->request_queue->nrequests)++] =
+					request;
+
 				this->state = HTTP_REQUEST_GARBAGE;
 
 				break;

src/server/handle_accept.c

@@ -9,8 +9,12 @@ serverHandleAccept(Server this)
 		acc = socketAccept(this->sock, remoteAddr);
 
 		if (-1 != acc->handle) {
-			(this->conns)[this->nfds].sock   = acc; // save the socket handle
-			(this->conns)[this->nfds].reader = clone(this->reader); // clone reader
+			//* save the socket handle
+			(this->conns)[this->nfds].sock   = acc; 
+
+			//* clone reader
+			(this->conns)[this->nfds].reader = clone(this->reader);
+
 			(this->fds)[this->nfds].fd       = acc->handle;
 			(this->fds)[this->nfds].events   = POLLIN;
 			this->nfds++;

src/server/run.c

@@ -10,6 +10,13 @@
 #include "signalHandling.h"
 #include "interface/class.h"
 #include "interface/stream_reader.h"
+#include "interface/logger.h"
+
+//* @TODO: to be removed
+#include "http/request.h"
+#include "http/request_parser.h"
+#include "http/request_queue.h"
+//* until here
 
 #undef  MAX
 #define MAX(x,y) ((x) > (y) ? (x) : (y))
@@ -21,11 +28,18 @@
 void
 serverRun(Server this)
 {
-	/*
-	 * @TODO again...add verbosity to logger....
-	 */
     loggerLog(this->logger, LOGGER_INFO, "service started");
 
+	/**
+	 * @TODO: actually this is the main loop of my server. When
+	 * stuff becomes more complicated it might be feasabible to
+	 * split stuff into separate processes. This will definetly
+	 * involve some IPC and syncing. Right now as this is actually
+	 * only a simple HTTP server implementation we go on with
+	 * this single process.
+	 * What we can first do to get some processing between read/write
+	 * cicles is to use the poll timeout.
+	 */
     while (!doShutdown) /* until error or signal  */
     {
 		int events;
@@ -46,6 +60,46 @@ serverRun(Server this)
 		 * handle reads 
 		 */
 		serverRead(this);
+
+		/**
+		 * do some other processing
+		 * @TODO: actually this will hard assume that our stream reader
+		 * is a http parser and it has its queue...think about more
+		 * generalizing here.
+		 */
+		{
+			int i;
+
+			for (i=1; i<this->nfds; i++) {
+				int              j;
+				HttpRequestQueue queue =
+					((HttpRequestParser)(this->conns)[i].reader)->request_queue;
+
+				for (j=0; j<queue->nrequests; j++) {
+					int         k;
+					HttpRequest request = queue->requests[j];
+
+					printf("method: %s\n", request->method);
+					printf("uri: %s\n", request->uri);
+					printf("version: %s\n", request->http_version);
+					puts("");
+
+					for (k=0; k<128; k++) {
+						if (NULL == (request->header)[k].name) break;
+						printf("header-name:  %s\n", (request->header)[k].name);
+						printf("header-value: %s\n", (request->header)[k].value);
+					}
+
+					delete(&request);
+				}
+				queue->nrequests = 0;
+			}
+		}
+
+
+		/**
+		 * handle writes
+		 */
     }
 }