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 bufferSize) {

    

    int bufferLen, wordIndex;

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

    

    // Initialize the tokenization state
    char* saveTokenState = buffer;
    char* token;

    // Tokenize the request line
    while ((token = strtok_r(saveTokenState, "\n\r", &saveTokenState)) != NULL) {
        printf("Token: %s\n", token);
    }

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


//    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;
//    }
    
    
}



// 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);
}