httpd_request.c

Go to the documentation of this file.

/*
 * Copyright 2011 Aalborg University. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY Aalborg University ''AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Aalborg University OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are those of the
 * authors and should not be interpreted as representing official policies, either expressed
 */

#include "httpd_request.h"
#include "http_parser.h"
#include "httpd_url_parser.h"
#include "httpd_header_parser.h"
#include "hpd/hpd_shared_api.h"
#include <string.h>
#include <stdlib.h>

enum state {
    S_START,           
    S_BEGIN,           
    S_URL,             
    S_HEADER_FIELD,    
    S_HEADER_VALUE,    
    S_HEADER_COMPLETE, 
    S_BODY,            
    S_COMPLETE,        
    S_STOP,            
    S_ERROR            
};

struct hpd_httpd_request
{
    const hpd_module_t *context;
    hpd_httpd_t *webserver;         
    hpd_httpd_settings_t *settings; 
    hpd_tcpd_conn_t *conn;          
    http_parser parser;             
    struct up *url_parser;          
    struct hp *header_parser;       
    enum state state;               
    char *url;                      
    hpd_map_t *arguments;           
    hpd_map_t *headers;             
    hpd_map_t *cookies;             
    void* data;                     
    hpd_httpd_method_t method;
};

// Methods for http_parser settings
static int parser_msg_begin(http_parser *parser);
static int parser_url      (http_parser *parser, const char *buf, size_t len);
static int parser_hdr_field(http_parser *parser, const char *buf, size_t len);
static int parser_hdr_value(http_parser *parser, const char *buf, size_t len);
static int parser_hdr_cmpl (http_parser *parser);
static int parser_body     (http_parser *parser, const char *buf, size_t len);
static int parser_msg_cmpl (http_parser *parser);

static http_parser_settings parser_settings =
        {
                .on_message_begin = parser_msg_begin,
                .on_url = parser_url,
                .on_status = NULL,
                .on_header_field = parser_hdr_field,
                .on_header_value = parser_hdr_value,
                .on_headers_complete = parser_hdr_cmpl,
                .on_body = parser_body,
                .on_message_complete = parser_msg_cmpl
        };

static hpd_error_t url_parser_path_complete(void *data, const char* parsedSegment, size_t segment_length)
{
    hpd_httpd_request_t *req = data;
    char *newUrl = realloc(req->url, sizeof(char)*(segment_length+1));
    if (!newUrl) HPD_LOG_RETURN_E_NULL(req->context);
    req->url = newUrl;
    strncpy(req->url, parsedSegment, segment_length);
    req->url[segment_length] = '\0';

    return HPD_E_SUCCESS;
}

static hpd_error_t url_parser_key_value(void *data, const char *key, size_t key_len, const char *value, size_t value_len)
{
    hpd_httpd_request_t *req = data;
    return hpd_map_set_n(req->arguments, key, key_len, value, value_len);
}

static hpd_error_t header_parser_field_value_pair_complete(void* data, const char* field, size_t field_length, const char* value, size_t value_length)
{
    hpd_error_t rc;
    hpd_httpd_request_t *req = data;

    const char *existing;
    switch ((rc = hpd_map_get_n(req->headers, field, field_length, &existing))) {
        case HPD_E_SUCCESS:
        case HPD_E_NOT_FOUND:
            break;
        default:
            return rc;
    }

    // If cookie, then store it in cookie list
    if (strncmp(field, "Cookie", 6) == 0) {
        size_t key_s = 0, key_e, val_s, val_e;

        while (key_s < value_length) {
            for (key_e = key_s; key_e < value_length && value[key_e] != '='; key_e++);
            if (key_e == value_length) HPD_LOG_RETURN(req->context, HPD_E_ARGUMENT, "Parse error.");
            val_s = key_e + 1;
            for (val_e = val_s; val_e < value_length && value[val_e] != ';'; val_e++);
            if (key_e-key_s > 0 && val_e-val_s > 0) {
                if ((rc = hpd_map_set_n(req->cookies, &value[key_s], (size_t) key_e - key_s, &value[val_s], val_e - val_s))) return rc;
            } else {
                HPD_LOG_RETURN(req->context, HPD_E_ARGUMENT, "Parse error.");
            }
            key_s = val_e + 2;
        }
    }

    // Store header in headers list
    if (existing) {
        // Combine values
        size_t new_len = strlen(existing) + 1 + value_length + 1;
        char *new = malloc(new_len * sizeof(char));
        if (!new) HPD_LOG_RETURN_E_ALLOC(req->context);
        strcpy(new, existing);
        strcat(new, ",");
        strncat(new, value, value_length);
        new[new_len-1] = '\0';

        // Replace
        rc = hpd_map_set_n(req->headers, field, field_length, new, new_len);

        // Clean up
        free(new);

        if (rc) return rc;
    } else {
        if ((rc = hpd_map_set_n(req->headers, field, field_length, value, value_length))) return rc;
    }

    return HPD_E_SUCCESS;
}

static int parser_msg_begin(http_parser *parser)
{
    hpd_httpd_return_t stat;
    hpd_httpd_request_t *req = parser->data;
    const hpd_httpd_settings_t *settings = req->settings;

    switch (req->state) {
        case S_STOP:
            return 1;
        case S_START:
            req->state = S_BEGIN;
            // Send request begin
            if(settings->on_req_begin && (stat = settings->on_req_begin(req->webserver, req, settings->httpd_ctx, &req->data))) {
                req->state = S_STOP; return stat;
            }

            return 0;
        default:
            HPD_LOG_ERROR(req->context, "Unexpected state.");
            req->state = S_ERROR;
            return 1;
    }
}

static int parser_url(http_parser *parser, const char *buf, size_t len)
{
    hpd_error_t rc;
    hpd_httpd_return_t stat;
    hpd_httpd_request_t *req = parser->data;
    hpd_httpd_settings_t *settings = req->settings;

    switch ((enum http_method) req->parser.method) {
        case HTTP_GET:
            req->method = HPD_HTTPD_M_GET;
            break;
        case HTTP_PUT:
            req->method = HPD_HTTPD_M_PUT;
            break;
        case HTTP_OPTIONS:
            req->method = HPD_HTTPD_M_OPTIONS;
            break;
        default:
            req->method = HPD_HTTPD_M_UNKNOWN;
            break;
    }

    switch (req->state) {
        case S_STOP:
            return 1;
        case S_BEGIN:
            req->state = S_URL;
        case S_URL:
            if ((rc = up_add_chunk(req->url_parser, buf, len))) {
                HPD_LOG_ERROR(req->context, "URL parser failed (code: %d).", rc);
                req->state = S_ERROR;
                return 1;
            }
            if(settings->on_req_url && (stat = settings->on_req_url(req->webserver, req, settings->httpd_ctx, &req->data, buf, len))) {
                req->state = S_STOP;
                return stat;
            }
            return 0;
        default:
            HPD_LOG_ERROR(req->context, "Unexpected state.");
            req->state = S_ERROR;
            return 1;
    }
}

static int parser_hdr_field(http_parser *parser, const char *buf, size_t len)
{
    hpd_error_t rc;
    hpd_httpd_return_t stat;
    hpd_httpd_request_t *req = parser->data;
    hpd_httpd_settings_t *settings = req->settings;

    switch (req->state) {
        case S_STOP:
            return 1;
        case S_URL:
            if ((rc = up_complete(req->url_parser))) {
                HPD_LOG_ERROR(req->context, "URL parser failed (code: %d).", rc);
                req->state = S_ERROR;
                return 1;
            }
            if(settings->on_req_url_cmpl && (stat = settings->on_req_url_cmpl(req->webserver, req, settings->httpd_ctx, &req->data))) {
                req->state = S_STOP;
                return stat;
            }
        case S_HEADER_VALUE:
            req->state = S_HEADER_FIELD;
        case S_HEADER_FIELD:
            if ((rc = hp_on_header_field(req->header_parser, buf, len))) {
                HPD_LOG_ERROR(req->context, "Header parser failed (code: %d).", rc);
                req->state = S_ERROR;
                return 1;
            }
            if(settings->on_req_hdr_field && (stat = settings->on_req_hdr_field(req->webserver, req, settings->httpd_ctx, &req->data, buf, len))) {
                req->state = S_STOP;
                return stat;
            }
            return 0;
        default:
            HPD_LOG_ERROR(req->context, "Unexpected state.");
            req->state = S_ERROR;
            return 1;
    }
}

static int parser_hdr_value(http_parser *parser, const char *buf, size_t len)
{
    hpd_error_t rc;
    hpd_httpd_return_t stat;
    hpd_httpd_request_t *req = parser->data;
    hpd_httpd_settings_t *settings = req->settings;

    switch (req->state) {
        case S_STOP:
            return 1;
        case S_HEADER_FIELD:
            req->state = S_HEADER_VALUE;
        case S_HEADER_VALUE:
            if ((rc = hp_on_header_value(req->header_parser, buf, len))) {
                HPD_LOG_ERROR(req->context, "Header parser failed (code: %d).", rc);
                req->state = S_ERROR;
                return 1;
            }
            if(settings->on_req_hdr_value && (stat = settings->on_req_hdr_value(req->webserver, req, settings->httpd_ctx, &req->data, buf, len))) {
                req->state = S_STOP;
                return stat;
            }
            return 0;
        default:
            HPD_LOG_ERROR(req->context, "Unexpected state.");
            req->state = S_ERROR;
            return 1;
    }
}

static int parser_hdr_cmpl(http_parser *parser)
{
    hpd_error_t rc;
    hpd_httpd_return_t stat;
    hpd_httpd_request_t *req = parser->data;
    hpd_httpd_settings_t *settings = req->settings;

    switch (req->state) {
        case S_STOP:
            return 1;
        case S_URL:
            if ((rc = up_complete(req->url_parser))) {
                HPD_LOG_ERROR(req->context, "Header parser failed (code: %d).", rc);
                req->state = S_ERROR;
                return 1;
            }
            if(settings->on_req_url_cmpl && (stat = settings->on_req_url_cmpl(req->webserver, req, settings->httpd_ctx, &req->data))){
                req->state = S_STOP;
                return stat;
            }
        case S_HEADER_VALUE:
            if ((rc = hp_on_header_complete(req->header_parser))) {
                HPD_LOG_ERROR(req->context, "Header parser failed (code: %d).", rc);
                req->state = S_ERROR;
                return 1;
            }
            req->state = S_HEADER_COMPLETE;
            if(settings->on_req_hdr_cmpl && (stat = settings->on_req_hdr_cmpl(req->webserver, req, settings->httpd_ctx, &req->data))) {
                req->state = S_STOP;
                return stat;
            }
            return 0;
        default:
            HPD_LOG_ERROR(req->context, "Unexpected state.");
            req->state = S_ERROR;
            return 1;
    }
}

static int parser_body(http_parser *parser, const char *buf, size_t len)
{
    hpd_httpd_return_t stat;
    hpd_httpd_request_t *req = parser->data;
    hpd_httpd_settings_t *settings = req->settings;

    switch (req->state) {
        case S_STOP:
            return 1;
        case S_HEADER_COMPLETE:
            req->state = S_BODY;
        case S_BODY:
            if (settings->on_req_body) {
                stat = settings->on_req_body(req->webserver, req, settings->httpd_ctx, &req->data, buf, len);
                if (stat) { req->state = S_STOP; return stat; }
            }
            return 0;
        default:
            HPD_LOG_ERROR(req->context, "Unexpected state.");
            req->state = S_ERROR;
            return 1;
    }
}

static int parser_msg_cmpl(http_parser *parser)
{
    hpd_httpd_return_t stat;
    hpd_httpd_request_t *req = parser->data;
    hpd_httpd_settings_t *settings = req->settings;

    switch (req->state) {
        case S_STOP:
            return 1;
        case S_HEADER_COMPLETE:
        case S_BODY:
            req->state = S_COMPLETE;
            if(settings->on_req_cmpl && (stat = settings->on_req_cmpl(req->webserver, req, settings->httpd_ctx, &req->data))) {
                req->state = S_STOP;
                return stat;
            }
            return 0;
        default:
            HPD_LOG_ERROR(req->context, "Unexpected state.");
            req->state = S_ERROR;
            return 1;
    }
}

hpd_error_t http_request_create(hpd_httpd_request_t **req, hpd_httpd_t *httpd, hpd_httpd_settings_t *settings,
                                hpd_tcpd_conn_t *conn, const hpd_module_t *context)
{
    if (!context) return HPD_E_NULL;
    if (!req || !httpd || !settings || !conn) HPD_LOG_RETURN_E_NULL(context);

    hpd_error_t rc, rc2;

    (*req) = malloc(sizeof(hpd_httpd_request_t));
    if(!(*req)) HPD_LOG_RETURN_E_ALLOC(context);

    // Init references
    (*req)->context = context;
    (*req)->webserver = httpd;
    (*req)->conn = conn;
    (*req)->settings = settings;

    // Init parser
    http_parser_init(&((*req)->parser), HTTP_REQUEST);
    (*req)->parser.data = (*req);
    (*req)->state = S_START;

    // Init URL Parser
    struct up_settings up_settings = UP_SETTINGS_DEFAULT;
    up_settings.on_path_complete = url_parser_path_complete;
    up_settings.on_key_value = url_parser_key_value;
    if ((rc = up_create(&(*req)->url_parser, &up_settings, context, (*req)))) goto error;

    // Init Header Parser
    struct hp_settings hp_settings = HP_SETTINGS_DEFAULT;
    hp_settings.data = (*req);
    hp_settings.on_field_value_pair = header_parser_field_value_pair_complete;
    if ((rc = hp_create(&(*req)->header_parser, &hp_settings, context))) goto error;

    // Create linked maps
    if ((rc = hpd_map_alloc(&(*req)->arguments))) goto error;
    if ((rc = hpd_map_alloc(&(*req)->headers))) goto error;
    if ((rc = hpd_map_alloc(&(*req)->cookies))) goto error;

    // Other field to init
    (*req)->url = NULL;
    (*req)->data = NULL;

    return HPD_E_SUCCESS;
    
    error:
        if ((rc2 = http_request_destroy(*req)))
            HPD_LOG_ERROR(context, "Failed to destroy request (code: %d)\n", rc2);
        return rc;
}

hpd_error_t http_request_destroy(hpd_httpd_request_t *req)
{
    if (!req) return HPD_E_NULL;
    
    hpd_error_t rc = HPD_E_SUCCESS, tmp;

    // Call callback
    hpd_httpd_settings_t *settings = req->settings;
    if (settings->on_req_destroy)
        settings->on_req_destroy(req->webserver, req, settings->httpd_ctx, &req->data);

    // Free request
    if ((tmp = up_destroy(req->url_parser)) && !rc) rc = tmp;
    if ((tmp = hpd_map_free(req->arguments)) && !rc) rc = tmp;
    if ((tmp = hpd_map_free(req->headers)) && !rc) rc = tmp;
    if ((tmp = hpd_map_free(req->cookies)) && !rc) rc = tmp;
    if ((tmp = hp_destroy(req->header_parser)) && !rc) rc = tmp;
    free(req->url);
    free(req);
    
    return rc;
}

hpd_error_t http_request_parse(hpd_httpd_request_t *req, const char *buf, size_t len)
{
    size_t read = http_parser_execute(&req->parser, &parser_settings, buf, len);

    enum http_errno err = HTTP_PARSER_ERRNO(&req->parser);

    switch (err) {
        case HPE_OK:
            break;
        case HPE_CB_message_begin:
        case HPE_CB_url:
        case HPE_CB_header_field:
        case HPE_CB_header_value:
        case HPE_CB_headers_complete:
        case HPE_CB_body:
        case HPE_CB_message_complete:
        case HPE_CB_status:
        case HPE_CB_chunk_header:
        case HPE_CB_chunk_complete:
            if (req->state == S_STOP) break;
        case HPE_INVALID_EOF_STATE:
        case HPE_HEADER_OVERFLOW:
        case HPE_CLOSED_CONNECTION:
        case HPE_INVALID_VERSION:
        case HPE_INVALID_STATUS:
        case HPE_INVALID_METHOD:
        case HPE_INVALID_URL:
        case HPE_INVALID_HOST:
        case HPE_INVALID_PORT:
        case HPE_INVALID_PATH:
        case HPE_INVALID_QUERY_STRING:
        case HPE_INVALID_FRAGMENT:
        case HPE_LF_EXPECTED:
        case HPE_INVALID_HEADER_TOKEN:
        case HPE_INVALID_CONTENT_LENGTH:
        case HPE_UNEXPECTED_CONTENT_LENGTH:
        case HPE_INVALID_CHUNK_SIZE:
        case HPE_INVALID_CONSTANT:
        case HPE_INVALID_INTERNAL_STATE:
        case HPE_STRICT:
        case HPE_PAUSED:
        case HPE_UNKNOWN:
            HPD_LOG_RETURN(req->context, HPD_E_ARGUMENT, "HTTP Parser failed with message: %s (code: %i).",
                           http_errno_description(err), err);
    }

    if (read != len  && req->state != S_STOP)
        HPD_LOG_RETURN(req->context, HPD_E_STATE, "Unexpected state.");

    if (req->parser.upgrade)
        HPD_LOG_RETURN(req->context, HPD_E_ARGUMENT, "Do not support HTTP upgrade messages.");

    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_request_get_method(hpd_httpd_request_t *req, hpd_httpd_method_t *method)
{
    if (!req) return HPD_E_NULL;
    if (!method) HPD_LOG_RETURN_E_NULL(req->context);

    (*method) = req->method;
    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_request_get_url(hpd_httpd_request_t *req, const char **url)
{
    if (!req) return HPD_E_NULL;
    if (!url) HPD_LOG_RETURN_E_NULL(req->context);

    (*url) = req->url;
    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_request_get_headers(hpd_httpd_request_t *req, hpd_map_t **headers)
{
    if (!req) return HPD_E_NULL;
    if (!headers) HPD_LOG_RETURN_E_NULL(req->context);

    (*headers) = req->headers;
    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_request_get_header(hpd_httpd_request_t *req, const char *key, const char **value)
{
    if (!req) return HPD_E_NULL;
    if (!key || !value) HPD_LOG_RETURN_E_NULL(req->context);

    return hpd_map_get(req->headers, key, value);
}

hpd_error_t hpd_httpd_request_get_arguments(hpd_httpd_request_t *req, hpd_map_t **arguments)
{
    if (!req) return HPD_E_NULL;
    if (!arguments) HPD_LOG_RETURN_E_NULL(req->context);

    (*arguments) = req->arguments;
    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_request_get_argument(hpd_httpd_request_t *req, const char *key, const char **val)
{
    if (!req) return HPD_E_NULL;
    if (!key || !val) HPD_LOG_RETURN_E_NULL(req->context);

    return hpd_map_get(req->arguments, key, val);
}

hpd_error_t hpd_httpd_request_get_cookies(hpd_httpd_request_t *req, hpd_map_t **cookies)
{
    if (!req) return HPD_E_NULL;
    if (!cookies) HPD_LOG_RETURN_E_NULL(req->context);

    (*cookies) = req->cookies;
    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_request_get_cookie(hpd_httpd_request_t *req, const char *key, const char **val)
{
    if (!req) return HPD_E_NULL;
    if (!key || !val) HPD_LOG_RETURN_E_NULL(req->context);

    return hpd_map_get(req->cookies, key, val);
}

hpd_error_t http_request_get_connection(hpd_httpd_request_t *req, hpd_tcpd_conn_t **conn)
{
    if (!req) return HPD_E_NULL;
    if (!conn) HPD_LOG_RETURN_E_NULL(req->context);

    (*conn) = req->conn;
    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_request_get_ip(hpd_httpd_request_t *req, const char **ip)
{
    if (!req) return HPD_E_NULL;
    if (!ip) HPD_LOG_RETURN_E_NULL(req->context);

    return hpd_tcpd_conn_get_ip(req->conn, ip);
}

hpd_error_t hpd_httpd_request_keep_open(hpd_httpd_request_t *req)
{
    if (!req) return HPD_E_NULL;

    return hpd_tcpd_conn_keep_open(req->conn);
}

hpd_error_t http_request_get_context(hpd_httpd_request_t *req, const hpd_module_t **context)
{
    if (!req) return HPD_E_NULL;
    if (!context) HPD_LOG_RETURN_E_NULL(req->context);

    (*context) = req->context;
    return HPD_E_SUCCESS;
}