fix for windows

[webserver.git] / http.c

#include <malloc.h>
#include <string.h>
#include <time.h>

#include "debug.h"
#include "file.h"

#include "http.h"

#define BUFFER_SIZE 128

#define HTTP_VERSION "HTTP/1.0"
#define SERVER_NAME "Webserver/0.0.1"

char *codes[15] = {
    "200 OK",
    "201 Created",
    "202 Accepted",
    "204 No Content",
    "301 Moved Permanently",
    "302 Moved Temporarily",
    "304 Not Modified",
    "400 Bad Request",
    "401 Unauthorized",
    "403 Forbidden",
    "404 Not Found",
    "500 Internal Server Error",
    "501 Not Implemented",
    "502 Bad Gateway",
    "503 Service Unavailable"};

typedef enum {
    c200 = 0, c201, c202, c204,
    c301, c302, c304, c400,
    c401, c403, c404, c500,
    c501, c502, c503
} code_t;

typedef enum {
    not_supported_e = 0, get_e, head_e, post_e
} method_t;

typedef struct {
    char *allow;
    char *authorization;
    char *content_encoding;
    char *content_length;
    char *content_type;
    char *date;
    char *expires;
    char *from;
    char *if_modified_since;
    char *last_modified;
    char *location;
    char *pragma;
    char *referer;
    char *server;
    char *user_agent;
    char *www_authenticate;
} header_t;

/* print header values */

void print_header_values (header_t *header)
{
    printf ("Header values\n");
    if (header->allow) printf ("allow = '%s'\n", header->allow);
    if (header->authorization) printf ("authorization = '%s'\n", header->authorization);
    if (header->content_encoding) printf ("content_encoding = '%s'\n", header->content_encoding);
    if (header->content_length) printf ("content_length = '%s'\n", header->content_length);
    if (header->content_type) printf ("content_type = '%s'\n", header->content_type);
    if (header->date) printf ("date = '%s'\n", header->date);
    if (header->expires) printf ("expires = '%s'\n", header->expires);
    if (header->from) printf ("from = '%s'\n", header->from);
    if (header->if_modified_since) printf ("if_modified_since = '%s'\n", header->if_modified_since);
    if (header->last_modified) printf ("last_modified = '%s'\n", header->last_modified);
    if (header->location) printf ("location = '%s'\n", header->location);
    if (header->pragma) printf ("pragma = '%s'\n", header->pragma);
    if (header->referer) printf ("referer = '%s'\n", header->referer);
    if (header->server) printf ("server = '%s'\n", header->server);
    if (header->user_agent) printf ("user_agent = '%s'\n", header->user_agent);
    if (header->www_authenticate) printf ("www_authenticate = '%s'\n", header->www_authenticate);
}

/* find sequence*/

char *find_sequence (char *data, int len, char *seq, char **pdata)
{

    int size = strlen (seq);

    int i;
    for (i = 0; i < len - size + 1; i++) {
        if (strncmp (data + i, seq, size) == 0) {
            data[i] = 0;
            if (pdata != NULL) {
                *pdata = data + i + size;
            }
            return data;
        }
    }

    return NULL;
}

/* response entity */

int add_line (char **buffer, char *str)
{
    int len = strlen (*buffer) + strlen (str) + 1;
    *buffer = realloc (*buffer, len);
    strcat (*buffer, str);
    return len;
}

int add_status_line (char **buffer, code_t code)
{
    char tmp[BUFFER_SIZE] = {0};

    /* Status */
    sprintf (tmp, "%s %s\r\n", HTTP_VERSION, codes[code]);
    add_line (buffer, tmp);

    return strlen (*buffer);
}

int add_general_header (char **buffer)
{
    char tmp[BUFFER_SIZE] = {0};

    /* Date */
    time_t ts = time (NULL);
    sprintf (tmp, "Date: %s\r\n", ctime (&ts));
    add_line (buffer, tmp);

    /* Pragma */

    return strlen (*buffer);
}

int add_response_header (char **buffer, char *uri)
{
    char tmp[BUFFER_SIZE] = {0};

    /* Location */
    sprintf (tmp, "Location: %s\r\n", uri);
    add_line (buffer, tmp);

    /* Server */
    sprintf (tmp, "Server: %s\r\n", SERVER_NAME);
    add_line (buffer, tmp);

    /* WWW-Authentificate */

    return strlen (*buffer);
}

int add_entity (char **buffer, char *entity, int size, char *type, char *encoding)
{
    char tmp[BUFFER_SIZE] = {0};
    int len = strlen (*buffer);

    /* Allow */
    /* Expires */
    /* Last-Modified */

    if (entity != NULL) {

        /* Content-Encoding */
        if (encoding != NULL) {
            sprintf (tmp, "Content-Encoding: %s\r\n", encoding);
            add_line (buffer, tmp);
        }

        /* Content-Length */
        sprintf (tmp, "Content-Length: %d\r\n", size);
        add_line (buffer, tmp);

        /* Content-Type */
        sprintf (tmp, "Content-Type: %s\r\n", type);
        add_line (buffer, tmp);

        add_line (buffer, "\r\n");

        /* Entity */
        len = strlen (*buffer);
        *buffer = realloc (*buffer, len + size);
        memcpy (*buffer + len, entity, size);
        len += size;
    }

    return len;
}

/* error 400 */

int error_400 (char **buffer)
{
    add_status_line (buffer, c400);
    add_general_header (buffer);
    add_response_header (buffer, NULL);

    char *response = "<html><head><title>Error 400</title></head><body><p>Bad Request</p></body></html>";
    return add_entity (buffer, response, strlen (response), "text/html", "iso-8859-1");
}

/* error 404 */

int error_404 (char **buffer, char *uri)
{
    add_status_line (buffer, c404);
    add_general_header (buffer);
    add_response_header (buffer, uri);

    char *response = "<html><head><title>Error 404</title></head><body><p>File not found</p></body></html>";
    return add_entity (buffer, response, strlen (response), "text/html", "iso-8859-1");
}

/* response html */

int response_html (char **buffer, char *location, char *response)
{
    add_status_line (buffer, c200);
    add_general_header (buffer);
    add_response_header (buffer, location);

    return add_entity (buffer, response, strlen (response), "text/html", "iso-8859-1");
}

/* trim string */

char *trim (char *str)
{
    if (str != NULL) {
        while ((*str == ' ') || (*str == '\t')) {
            str++;
        }
    }
    return str;
}

/* main HTTP processing */

int processing (char *data, int len, char *root, char **pdata)
{
    VERBOSE (DEBUG, PRINT ("Start processing\n"));

    /* check method */
    char *line = find_sequence (data, len, "\r\n", &data);
    if (line == NULL) {
        VERBOSE (WARNING, PRINT ("Unknown received data\n"));
        if (pdata != NULL) {
            *pdata = NULL;
        }
        return 0;
    }
    VERBOSE (DEBUG, PRINT ("Command line: '%s'\n", line));

    char *method = strtok (line, " ");
    char *uri = strtok (NULL, " ");
    char *version = strtok (NULL, " ");
    method_t type = not_supported_e;
    if (strcmp (method, "GET") == 0) {
        type = get_e;
    } else if (strcmp ("HEAD", method) == 0) {
        type = head_e;
    } else if (strcmp ("POST", method) == 0) {
        type = post_e;
    } else {
        VERBOSE (WARNING, PRINT ("Unkown method: %s\n", method));
        return error_400 (pdata);
    }
    VERBOSE (INFO, PRINT ("%s %s (%s)\n", (type == get_e) ? "Get" : (type == head_e) ? "Head" : "Post", uri, version));

    /* analyse uri */
    char *filename = (char *)calloc (strlen (root) + strlen (uri) + 2, 1);
    //sprintf (filename, "%s%s%s", root, ((root[strlen (root) - 1] != '/') && (uri[0] != '/')) ? "/" : "", uri);
    sprintf (filename, "%s/%s", root, uri);

    /* check header */
    header_t header = {0};
    while (strcmp (line = find_sequence (data, len, "\r\n", &data), "") != 0) {
        VERBOSE (DEBUG, PRINT ("Header line: '%s'\n", line));
        char *field = strtok (line, ":");
        char *value = trim (strtok (NULL, "\r"));
        VERBOSE (DEBUG, PRINT ("Field: %s\nValue: %s\n", field, value));
        if (*line == 0) {
            break;
        }
        
        VERBOSE (DEBUG, PRINT ("Analyse field\n"));
        if (strcmp (field, "Allow") == 0) {
            header.allow = value;
        } else if (strcmp (field, "Authorization") == 0) {
            header.authorization = value;
        } else if (strcmp (field, "Content-Encoding") == 0) {
            header.content_encoding = value;
        } else if (strcmp (field, "Content-Length") == 0) {
            header.content_length = value;
        } else if (strcmp (field, "Content-Type") == 0) {
            header.content_type = value;
        } else if (strcmp (field, "Date") == 0) {
            header.date = value;
        } else if (strcmp (field, "Expires") == 0) {
            header.expires = value;
        } else if (strcmp (field, "From") == 0) {
            header.from = value;
        } else if (strcmp (field, "If-Modified-Since") == 0) {
            header.if_modified_since = value;
        } else if (strcmp (field, "Last-Modified") == 0) {
            header.last_modified = value;
        } else if (strcmp (field, "Location") == 0) {
            header.location = value;
        } else if (strcmp (field, "Pragma") == 0) {
            header.pragma = value;
        } else if (strcmp (field, "Referer") == 0) {
            header.referer = value;
        } else if (strcmp (field, "Server") == 0) {
            header.server = value;
        } else if (strcmp (field, "User-Agent") == 0) {
            header.user_agent = value;
        } else if (strcmp (field, "WWW-Authenticate") == 0) {
            header.www_authenticate = value;
        } else {
            VERBOSE (WARNING, PRINT ("Unknown header field: '%s'\n", field));
        }
    }
    VERBOSE (DEBUG, print_header_values (&header));

    /* response */
    char *buffer = NULL;
    switch (type) {
    case get_e:
        VERBOSE (DEBUG, PRINT ("Read file %s\n", filename));
        len = readfile (&buffer, filename);
        if (len == 0) {
            len = error_404 (pdata, "http://localhost/");
        } else {
            len = response_html (pdata, "http://localhost/", buffer);
            free (buffer);
        }
        break;
    case head_e:
        break;
    case post_e:
        VERBOSE (DEBUG, PRINT ("Write file %s\n", filename));
        break;
    case not_supported_e:
        break;
    }

    /* cleaning */
    VERBOSE (DEBUG, PRINT ("Cleaning\n"));
    if (filename) {
        VERBOSE (DEBUG, PRINT ("Cleaning filename\n"));
        free (filename);
    }

    return len;
}

/* vim: set ts=4 sw=4 et: */