239 lines
7.2 KiB
C
239 lines
7.2 KiB
C
#include "http.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
static const char *EMPTY_STRING = "";
|
|
|
|
HTTPHeaderList *http_header_list_push(HTTPHeaderList *list, const char *key, const char *value) {
|
|
HTTPHeaderList *new = malloc(sizeof(HTTPHeaderList));
|
|
if (!new) {
|
|
return NULL;
|
|
}
|
|
new->key_length = strlen(key);
|
|
new->key = malloc(new->key_length + 1);
|
|
if (!new->key) {
|
|
free(new);
|
|
return NULL;
|
|
}
|
|
memcpy(new->key, key, new->key_length + 1);
|
|
new->value_length = strlen(value);
|
|
new->value = malloc(new->value_length + 1);
|
|
if (!new->value) {
|
|
free(new->key);
|
|
free(new);
|
|
return NULL;
|
|
}
|
|
memcpy(new->value, value, new->value_length + 1);
|
|
new->next = list;
|
|
return new;
|
|
}
|
|
|
|
void free_http_header_list(HTTPHeaderList *list) {
|
|
while (list) {
|
|
HTTPHeaderList *next = list->next;
|
|
free(list->key);
|
|
free(list->value);
|
|
free(list);
|
|
list = next;
|
|
}
|
|
}
|
|
|
|
const char *http_header_list_search(HTTPHeaderList *list, const char *key, const char *def) {
|
|
while (list) {
|
|
if (strcmp(list->key, key) == 0) {
|
|
return list->value;
|
|
}
|
|
list = list->next;
|
|
}
|
|
return def;
|
|
}
|
|
|
|
#define MAX_REQUEST_LENGTH 16384
|
|
#define MAX_METHOD_LENGTH 8
|
|
#define MAX_URI_LENGTH 64
|
|
#define MAX_VERSION_LENGTH 3
|
|
#define MAX_HEADER_KEY_LENGTH 128
|
|
#define MAX_HEADER_VALUE_LENGTH 128
|
|
|
|
#define RETURN_IF_READ_ERROR(s) \
|
|
if (ferror((s))) { \
|
|
return HRPR_READ_FAILED; \
|
|
}
|
|
|
|
// if an error occured, req->uri is not allocated
|
|
static HTTPRequestParseResult parse_method_uri_line(
|
|
FILE *stream, size_t *restrict bytes_read, HTTPRequest *restrict req) {
|
|
// allow for some leeway in passing incorrect methods
|
|
char method[MAX_METHOD_LENGTH + 1];
|
|
char uri[MAX_URI_LENGTH + 1];
|
|
char version_str[MAX_VERSION_LENGTH + 1];
|
|
char whitespace[4] = { 0, 0, 0, 0 };
|
|
ssize_t signed_bytes_read;
|
|
#define S1(s) #s
|
|
#define S(s) S1(s)
|
|
int nconv = fscanf(stream,
|
|
// clang-format off
|
|
"%" S(MAX_METHOD_LENGTH) "[a-zA-Z]"
|
|
"%c"
|
|
"%" S(MAX_URI_LENGTH) "[^ \n\r]"
|
|
"%c"
|
|
"HTTP/%" S(MAX_VERSION_LENGTH) "[0-9.]"
|
|
"%c%c"
|
|
"%zn",
|
|
// clang-format on
|
|
method, &whitespace[0], uri, &whitespace[1], version_str, &whitespace[2], &whitespace[3],
|
|
&signed_bytes_read);
|
|
#undef S
|
|
*bytes_read = signed_bytes_read;
|
|
RETURN_IF_READ_ERROR(stream);
|
|
if (nconv >= 1 && (nconv == 1 || whitespace[0] == ' ')) {
|
|
req->method = strdup(method);
|
|
if (!req->method) {
|
|
return HRPR_NO_MEM;
|
|
}
|
|
if (nconv >= 3 && (nconv == 3 || whitespace[1] == ' ')) {
|
|
req->uri = strdup(uri);
|
|
if (!req->uri) {
|
|
return HRPR_NO_MEM;
|
|
}
|
|
req->path = req->uri;
|
|
while (*req->path == '/') {
|
|
++req->path;
|
|
}
|
|
}
|
|
}
|
|
if (nconv != 7 || *uri != '/' || memcmp(whitespace, " \r\n", 4) != 0) {
|
|
return HRPR_BAD_FORMAT;
|
|
}
|
|
return strcmp(version_str, "1.1") == 0 ? HRPR_OK : HRPR_BAD_VERSION;
|
|
}
|
|
|
|
// return true if there are more headers and no error occurred, false otherwise
|
|
// this will *not* free LIST if an error occurs
|
|
static bool next_header(FILE *stream, size_t *restrict bytes_read,
|
|
HTTPRequestParseResult *restrict res, HTTPHeaderList *restrict *restrict list) {
|
|
char c = fgetc(stream);
|
|
RETURN_IF_READ_ERROR(stream);
|
|
if (c == '\r') {
|
|
c = fgetc(stream);
|
|
RETURN_IF_READ_ERROR(stream);
|
|
if (c != '\n') {
|
|
*res = HRPR_BAD_FORMAT;
|
|
return false;
|
|
}
|
|
*bytes_read = 2;
|
|
*res = HRPR_OK;
|
|
return false;
|
|
} else if (feof(stream)) {
|
|
*res = HRPR_BAD_FORMAT;
|
|
return false;
|
|
}
|
|
ungetc(c, stream);
|
|
char key[MAX_HEADER_KEY_LENGTH + 1];
|
|
char value[MAX_HEADER_VALUE_LENGTH + 1];
|
|
char whitespace[3];
|
|
ssize_t signed_bytes_read;
|
|
#define S1(s) #s
|
|
#define S(s) S1(s)
|
|
int nconv = fscanf(stream,
|
|
// clang-format off
|
|
"%" S(MAX_HEADER_KEY_LENGTH) "[a-zA-Z0-9.-]"
|
|
":%c"
|
|
"%" S(MAX_HEADER_VALUE_LENGTH) "[ -~]"
|
|
"%c%c"
|
|
"%zn",
|
|
// clang-format on
|
|
key, &whitespace[0], value, &whitespace[1], &whitespace[2], &signed_bytes_read);
|
|
#undef S
|
|
*bytes_read = signed_bytes_read;
|
|
RETURN_IF_READ_ERROR(stream);
|
|
if (nconv != 5 || memcmp(whitespace, " \r\n", 3) != 0) {
|
|
return HRPR_BAD_FORMAT;
|
|
}
|
|
*list = http_header_list_push(*list, key, value);
|
|
if (!*list) {
|
|
*res = HRPR_NO_MEM;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
HTTPRequestParseResult parse_http_request(FILE *stream, HTTPRequest *restrict out) {
|
|
out->uri = EMPTY_STRING;
|
|
out->path = EMPTY_STRING;
|
|
out->method = EMPTY_STRING;
|
|
out->headers = NULL;
|
|
size_t total_bytes;
|
|
HTTPRequestParseResult res;
|
|
if ((res = parse_method_uri_line(stream, &total_bytes, out)) != HRPR_OK) {
|
|
return res;
|
|
}
|
|
size_t bytes_read;
|
|
while (next_header(stream, &bytes_read, &res, &out->headers)) {
|
|
if ((total_bytes += bytes_read) > MAX_REQUEST_LENGTH) {
|
|
res = HRPR_BAD_FORMAT;
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void free_http_request(HTTPRequest *restrict req) {
|
|
if (req->method != EMPTY_STRING) {
|
|
free((char *) req->method);
|
|
}
|
|
if (req->uri != EMPTY_STRING) {
|
|
free((char *) req->uri);
|
|
}
|
|
free_http_header_list(req->headers);
|
|
}
|
|
|
|
const char *status_code_to_message(int status, size_t *restrict length) {
|
|
static const struct {
|
|
int code;
|
|
const char *msg;
|
|
size_t size;
|
|
} CODES[] = {
|
|
// can't get my local copy of clang-format (v18) to work with the autograder
|
|
// clang-format off
|
|
#define P(s, m) { s, m, sizeof(m) - 1 }
|
|
// clang-format on
|
|
P(200, "OK"),
|
|
P(201, "Created"),
|
|
P(400, "Bad Request"),
|
|
P(403, "Forbidden"),
|
|
P(404, "Not Found"),
|
|
P(500, "Internal Server Error"),
|
|
P(501, "Not Implemented"),
|
|
P(505, "Version Not Supported"),
|
|
#undef P
|
|
};
|
|
static const size_t NCODES = sizeof(CODES) / sizeof(CODES[0]);
|
|
for (size_t i = 0; i < NCODES; ++i) {
|
|
if (status == CODES[i].code) {
|
|
if (length) {
|
|
*length = CODES[i].size;
|
|
}
|
|
return CODES[i].msg;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void format_http_response(FILE *stream, HTTPResponse *restrict resp) {
|
|
assert(status_code_to_message(resp->status, NULL));
|
|
dprintf(fileno(stream), "HTTP/1.1 %d %s\r\n", resp->status,
|
|
status_code_to_message(resp->status, NULL));
|
|
dprintf(fileno(stream), "Content-Length: %zu\r\n", resp->body_length);
|
|
for (HTTPHeaderList *h = resp->headers; h; h = h->next) {
|
|
write(fileno(stream), h->key, h->key_length);
|
|
write(fileno(stream), ": ", 2);
|
|
write(fileno(stream), h->value, h->value_length);
|
|
write(fileno(stream), "\r\n", 2);
|
|
}
|
|
write(fileno(stream), "\r\n", 2);
|
|
}
|