cse-130-http-server/http.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);
}