diff options
| -rw-r--r-- | http.c | 188 | ||||
| -rw-r--r-- | http.h | 33 |
2 files changed, 221 insertions, 0 deletions
@@ -1,5 +1,6 @@ #include "http.h" +#include <ctype.h> #include <errno.h> #include <stdio.h> #include <stdlib.h> @@ -16,6 +17,42 @@ const char * status_str[] = { [STATUS_VERSION_NOT_SUPPORTED] = "505 Version Not Supported", }; +/// Allocates and initializes request structure. +/// \return Pointer to initialized request +/// \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_method; + + 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) + { + // TODO: free(request->data); data lifetime is now managed by plop, move it here + } + + if (NULL != request->headers) + { + free(request->headers); + } + + free(request); +} + /// Sends a simple response only with a status to the client. /// \param fd File descriptor of the client socket /// \param status HTTP response status code @@ -78,7 +115,158 @@ int collect_request(const int fd, char ** request) return -1; // TODO: Handle errors properly } + // TODO: Use struct request in plop + struct request * debug = new_request(); + debug->data = *request; + debug->length = length; + debug->step(debug); + + printf( + "(%.*s) [%.*s] %.*s\n", + debug->version.length, debug->data + debug->version.start, + debug->method.length, debug->data + debug->method.start, + debug->path.length, debug->data + debug->path.start); + + free_request(debug); + (*request)[length] = 0; return length; } + + +/// 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) +{ + char buffer[2] = {0, 0}; + while (request->position < request->length - 1) + { + memcpy(buffer, &request->data[request->position], 2); + if (0 == strncmp(buffer, "\r\n", 2)) + { + return request->position; + } + if (buffer[1] == '\r') + { + request->position += 1; + continue; + } + 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_method(struct request * request) +{ + request->method.length = read_until_char(request, ' '); + + if (0 == request->method.length) + { + return 0; + } + + request->step = parse_path; + + return parse_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_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_version; + + return parse_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_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 = NULL; // TODO: Parse headers + + return request->position; +} @@ -1,6 +1,31 @@ #ifndef HTTP_H #define HTTP_H +struct span +{ + int start; + int length; +}; + +struct header +{ + struct span name; + struct span value; +}; + +struct request +{ + int (* step)(struct request *); + char * data; + int length; + int position; + struct span method; + struct span path; + struct span version; + struct header * headers; + struct span body; +}; + enum status { STATUS_OK = 200, @@ -14,8 +39,16 @@ enum status extern const char * status_str[]; +struct request * new_request(void); +void free_request(struct request *); + int respond_only_status(int, enum status); int respond_with_body(int, enum status, const char *, int); + int collect_request(int, char **); +int parse_method(struct request *); +int parse_path(struct request *); +int parse_version(struct request *); + #endif // HTTP_H |