DesignedWorlds/source/http.c

#include "http.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>



HttpRequestHeader* createHttpRequest(char* uri, unsigned char method, char* host, char* accept, char* user_agent) {
    HttpRequestHeader* request = (HttpRequestHeader*) malloc(sizeof(HttpRequestHeader));

    if(request != NULL) {
        request->http_version = (char*) malloc(strlen("HTTP/1.1") + 1);
        strcpy(request->http_version, "HTTP/1.1");
        request->uri = (char*)malloc(strlen(uri) + 1);
        strcpy((char*)request->uri, uri);

        request->method = method;

        request->host = (char*)malloc(strlen(host) + 1);
        strcpy((char*)request->host, host);

        request->accept = (char*)malloc(strlen(accept) + 1);
        strcpy((char*)request->accept, accept);

        request->user_agent = (char*)malloc(strlen(user_agent) + 1);
        strcpy((char*)request->user_agent, user_agent);

    }

    return request;
}



// Function to receive an HTTP response
HttpResponseHeader* createHttpResponse(int statusCode,const char* contextType, 
        char* data, char* buffer, int bufferSize) {
    // TO DO: implement the actual receiving logic
    HttpResponseHeader* response = (HttpResponseHeader*)malloc(sizeof(HttpResponseHeader));
    response->http_version = (char*) malloc(strlen("HTTP/1.1") + 1);
    strcpy(response->http_version, "HTTP/1.1");
    response->content_length = strlen(data);
    response->content_type = (char*) malloc(strlen(contextType)+1);
    strcpy(response->content_type, contextType);
    switch(statusCode) {
        case 100:
            response->status_code = 100;
            response->status_text = (char*) malloc(strlen("Continue") + 1);
            strcpy(response->status_text, "Continue");
            break;
        case 200:
            response->status_code = 200;
            response->status_text = (char*) malloc(strlen("OK") + 1);
            strcpy(response->status_text, "OK");
            break;
        case 201:
            response->status_code = 201;
            response->status_text = (char*) malloc(strlen("Created") + 1);
            strcpy(response->status_text, "Created");
            break;
        case 301:
            response->status_code = 301;
            response->status_text = (char*) malloc(strlen("Moved Permanently") + 1);
            strcpy(response->status_text, "Moved Permanently");
            break;
        case 404:
            response->status_code = 404;
            response->status_text = (char*) malloc(strlen("Not Found") + 1);
            strcpy(response->status_text, "Not Found");
            break;
        default:
            response->status_code = statusCode;
            response->status_text = (char*) malloc(strlen("Unknown") + 1);
            strcpy(response->status_text, "Unknown");
            break;
    }

    HttpResponseHeaderToS(response, data, buffer, bufferSize);

    return response;
}

void HttpResponseHeaderToS(HttpResponseHeader* rh,char* d, char* buffer, int bufferSize) { 
    

        snprintf(buffer, bufferSize,
            "%s %u %s\r\n"
            "Content-Type: %s\r\n"
            "Content-Length: %d\r\n"
            "Server: My Simple Web Server\r\n\r\n%s",
            rh->http_version, rh->status_code, rh->status_text,
            rh->content_type, rh->content_length, d);

}

void HttpRequestHeaderFromS(HttpRequestHeader* rh, char* buffer) {
    
    int methodLen = 0;
    char methodStr[8] = "";
    if (strstr(buffer, "GET") != NULL) {
        rh->method = HTTP_GET;
    } else if (strstr(buffer, "POST") != NULL) {
        rh->method = HTTP_POST;
    } else if (strstr(buffer, "PUT") != NULL) {
        rh->method = HTTP_PUT;
    } else if (strstr(buffer, "DELETE") != NULL) {
        rh->method = HTTP_DELETE;
    } else if (strstr(buffer, "HEAD") != NULL) {
        rh->method = HTTP_HEAD;
    } else if (strstr(buffer, "OPTIONS") != NULL) {
        rh->method = HTTP_OPTIONS;
    } else if (strstr(buffer, "PATCH") != NULL) {
        rh->method = HTTP_PATCH;
    } else if (strstr(buffer, "CONNECT") != NULL) {
        rh->method = HTTP_CONNECT;
    } else if (strstr(buffer, "CONNECT") != NULL) {
        rh->method = HTTP_CONNECT;
    } else {
        rh->method = HTTP_UNKNOWN;
    }
    
    int bufferLen, wordIndex;

    // Find the bufferLen of the string
    bufferLen = strlen(buffer);
    int start, end = 0;



    // GET /path/to/file/ HTTP:1.1
}



// Function to free the memory allocated for an HTTP request header
void freeHttpRequest(HttpRequestHeader* request) {
    if (request == NULL) return;
    if (request->uri != NULL) free(request->uri);
    if (request->http_version != NULL) free(request->http_version);
    if (request->host != NULL) free(request->host);
    if (request->accept != NULL) free(request->accept);
    if (request->user_agent != NULL) free(request->user_agent);
}

// Function to free the memory allocated for an HTTP response header
void freeHttpResponse(HttpResponseHeader* response) {
    if (response == NULL) return;
    if (response->http_version != NULL) free(response->http_version);
    if (response->status_text != NULL) free(response->status_text);
}