diff --git a/ChangeLog b/ChangeLog index 13abc6a..19f810d 100644 --- a/ChangeLog +++ b/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 diff --git a/include/http/request_parser.h b/include/http/request_parser.h index 0681002..9fde863 100644 --- a/include/http/request_parser.h +++ b/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; }; diff --git a/include/http/request_queue.h b/include/http/request_queue.h index 6654aa0..8df553f 100644 --- a/include/http/request_queue.h +++ b/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__ */ diff --git a/src/Makefile.am b/src/Makefile.am index b9395fb..ba46b98 100644 --- a/src/Makefile.am +++ b/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/ diff --git a/src/http/request.c b/src/http/request.c index 0b7cc0e..b593b60 100644 --- a/src/http/request.c +++ b/src/http/request.c @@ -2,9 +2,10 @@ #include #include "class.h" -#include "http/request.h" #include "interface/class.h" +#include "http/request.h" + static void _free(void ** data) diff --git a/src/http/request_parser.c b/src/http/request_parser.c index 61978bc..b3c059b 100644 --- a/src/http/request_parser.c +++ b/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; iheader)[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; diff --git a/src/server/handle_accept.c b/src/server/handle_accept.c index cc89222..7a22216 100644 --- a/src/server/handle_accept.c +++ b/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++; diff --git a/src/server/run.c b/src/server/run.c index a7adaa2..18897b4 100644 --- a/src/server/run.c +++ b/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; infds; i++) { + int j; + HttpRequestQueue queue = + ((HttpRequestParser)(this->conns)[i].reader)->request_queue; + + for (j=0; jnrequests; 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 + */ } }