1 files changed, 317 insertions, 0 deletions
diff --git a/request.c b/request.c
new file mode 100644
index 0000000..f6f8a78
--- /dev/null
+++ b/request.c
@@ -0,0 +1,317 @@
+#include "request.h"
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "http.h"
+
+static const int REQUEST_DATA_SIZE = 4096;
+static const int MAX_HEADERS = 30;
+
+/// Allocates and initializes request structure.
+/// \return Pointer to initialized request or NULL in case of an error
+/// \see /free_request
+struct request * new_request(void)
+{
+	struct request * request = malloc(sizeof(struct request));
+
+	if (NULL == request)
+	{
+		return NULL;
+	}
+
+	memset(request, 0, sizeof(struct request));
+	request->step = parse_step_method;
+
+	request->data = malloc(REQUEST_DATA_SIZE);
+
+	if (NULL == request->data)
+	{
+		free(request);
+		return NULL;
+	}
+
+	return request;
+}
+
+/// Releases memory used by the request and the request itself.
+/// \param request Request to free
+/// \see /new_request
+void free_request(struct request * request)
+{
+	if (NULL != request->data)
+	{
+		free(request->data);
+	}
+
+	if (NULL != request->headerv)
+	{
+		free(request->headerv);
+	}
+
+	free(request);
+}
+
+/// Collects request between calls to `poll`.
+/// \param fd Client socket
+/// \param request Pointer to current request context of handled client
+/// \return Number of bytes parsed, -1 if an error occured or 0 if expects more data
+int parse_request(const int fd, struct request ** request)
+{
+	if (NULL == *request)
+	{
+		*request = new_request();
+		if (NULL == *request)
+		{
+			return -1;
+		}
+	}
+
+	// TODO: Expand buffer until EAGAIN or arbitrary limit
+	int length = read(fd, (*request)->data, REQUEST_DATA_SIZE - 1);
+
+	if (0 == length || (-1 == length && EWOULDBLOCK != errno && EAGAIN != errno))
+	{
+		return -1; // TODO: Handle errors properly
+	}
+
+	(*request)->data[length] = 0;
+	(*request)->length = length;
+
+	return (*request)->step(*request);
+}
+
+
+/// Progresses the readout of the request until delimiter is found.
+/// \param request Request to process
+/// \param delimiter Character that marks the end of the readout
+/// \return Position of the delimiter or 0 if the deliminter could not be found
+static int read_until_char(struct request * request, const char delimiter)
+{
+	char character;
+	while (request->position < request->length)
+	{
+		character = request->data[request->position];
+		if (delimiter == character)
+		{
+			return request->position;
+		}
+		request->position++;
+	}
+	return 0;
+}
+
+/// Progresses the readout of the request until non-whitespace character is found.
+/// \param request Request to process
+/// \return Position of the first non-whitespace character or 0 if it could not be found
+/// \see isalpha(3)
+static int read_until_word(struct request * request)
+{
+	char character;
+	while (request->position < request->length)
+	{
+		character = request->data[request->position];
+		if (!isspace(character))
+		{
+			return request->position;
+		}
+		request->position++;
+	}
+	return 0;
+}
+
+/// Progresses the readout of the request until line separator is found.
+/// \param request Request to process
+/// \return Position of the first byte of the separator or 0 if line separator could not be found
+static int read_rest_of_line(struct request * request)
+{
+	while (request->position < request->length - 1)
+	{
+		if ('\r' == request->data[request->position] && '\n' == request->data[request->position + 1])
+		{
+			return request->position;
+		}
+		else if ('\r' == request->data[request->position + 1])
+		{
+			request->position += 1;
+		}
+		else
+		{
+			request->position += 2;
+		}
+	}
+	return 0;
+}
+
+/// Parses method field of the request.
+/// \param request Request to process
+/// \return -1 if an error has occured, 0 if too little data available or total number of bytes processed
+int parse_step_method(struct request * request)
+{
+	request->method.length = read_until_char(request, ' ');
+
+	if (0 == request->method.length)
+	{
+		return 0;
+	}
+
+	request->step = parse_step_path;
+
+	return parse_step_path(request);
+}
+
+/// Parses path field of the request.
+/// \param request Request to process
+/// \return -1 if an error has occured, 0 if too little data available or total number of bytes processed
+// TODO: Consider spliting path into an actual path and arguments in this stage
+int parse_step_path(struct request * request)
+{
+	if (0 >= request->path.start)
+	{
+		request->path.start = read_until_word(request);
+
+		if (0 == request->path.start)
+		{
+			return 0;
+		}
+	}
+
+	const int result = read_until_char(request, ' ');
+
+	if (0 == result)
+	{
+		return 0;
+	}
+
+	request->path.length = request->position - request->path.start;
+	request->step = parse_step_version;
+
+	return parse_step_version(request);
+}
+
+/// Parses and verifies http version field of the request.
+/// \param request Request to process
+/// \return -1 if an error has occured, 0 if too little data available or total number of bytes processed
+// TODO: Return -1 if version is unsupported, meaning other than HTTP/1.1
+int parse_step_version(struct request * request)
+{
+	if (0 >= request->version.start)
+	{
+		request->version.start = read_until_word(request);
+
+		if (0 == request->version.start)
+		{
+			return 0;
+		}
+	}
+
+	const int result = read_rest_of_line(request);
+
+	if (0 == result)
+	{
+		return 0;
+	}
+
+	request->version.length = request->position - request->version.start;
+	request->step = parse_step_header_name;
+
+	return parse_step_header_name(request);
+}
+
+/// Parses and verifies name of a single header from the request.
+/// \param request Request to process
+/// \return -1 if an error has occured, 0 if too little data available or total number of bytes processed
+int parse_step_header_name(struct request * request)
+{
+	if (NULL == request->headerv)
+	{
+		request->headerv = malloc(sizeof(struct header) * MAX_HEADERS);
+		request->headerc = 0;
+		memset(request->headerv, 0, sizeof(struct header) * MAX_HEADERS);
+
+		if (NULL == request->headerv)
+		{
+			return -1;
+		}
+	}
+
+	// TODO: Check for the header section end without backtracking.
+	const int position = request->position;
+	int result = read_rest_of_line(request);
+
+	if (0 == result)
+	{
+		return 0;
+	}
+
+	if (2 == result - position)
+	{
+		// Header section ended, nothing left to parse.
+		return request->position + 2;
+	}
+
+	request->position = position;
+
+	if (0 >= request->headerv[request->headerc].name.start)
+	{
+		request->headerv[request->headerc].name.start = read_until_word(request);
+
+		if (0 == request->headerv[request->headerc].name.start)
+		{
+			return 0;
+		}
+	}
+
+	result = read_until_char(request, ':');
+
+	if (0 == result)
+	{
+		return 0;
+	}
+
+	request->headerv[request->headerc].name.length = request->position - request->headerv[request->headerc].name.start;
+	request->step = parse_step_header_value;
+
+	// Skip ':'
+	request->position++;
+
+	return parse_step_header_value(request);
+}
+
+/// Parses and verifies value of a single header from the request.
+/// \param request Request to process
+/// \return -1 if an error has occured, 0 if too little data available or total number of bytes processed
+int parse_step_header_value(struct request * request)
+{
+	if (0 >= request->headerv[request->headerc].value.start)
+	{
+		request->headerv[request->headerc].value.start = read_until_word(request);
+
+		if (0 == request->headerv[request->headerc].value.start)
+		{
+			return 0;
+		}
+	}
+
+	const int result = read_rest_of_line(request);
+
+	if (0 == result)
+	{
+		return 0;
+	}
+
+	request->headerv[request->headerc].value.length = request->position - request->headerv[request->headerc].value.start;
+	request->step = parse_step_header_name;
+	request->headerc++;
+
+	if (MAX_HEADERS == request->headerc)
+	{
+		return -1;
+	}
+
+	return parse_step_header_name(request);
+}