httpd_url_parser.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 <string.h>
#include <stdlib.h>

#include "httpd_url_parser.h"
#include "hpd/hpd_shared_api.h"

enum up_state {
    S_START,    
    S_PROTOCOL, 
    S_SLASH1,   
    S_SLASH2,   
    S_HOST,     
    S_PREPORT,  
    S_PORT,     
    S_SEGMENT,  
    S_KEY,      
    S_VALUE,    
    S_ERROR     
};

struct up {
    const hpd_module_t *context;
    struct up_settings *settings; 
    void *data;                   

    enum up_state state;          
    char *buffer;                 

    size_t protocol;              
    size_t protocol_l;            
    size_t host;                  
    size_t host_l;                
    size_t port;                  
    size_t port_l;                
    size_t path;                  
    size_t path_l;                
    size_t key_value;             
    size_t end;                   

    size_t last_key;              
    size_t last_key_l;            
    size_t last_value;            
    size_t last_value_l;          
    size_t last_path;             
    size_t last_path_l;           

    size_t parser;                
    size_t insert;                
};

hpd_error_t up_create(struct up **instance, struct up_settings *settings, const hpd_module_t *context, void *data)
{
    if (!context) return HPD_E_NULL;
    if (!instance || !settings) HPD_LOG_RETURN_E_NULL(context);

    (*instance) = malloc(sizeof(struct up));
    if (!(*instance)) return HPD_E_ALLOC;

    (*instance)->context = context;

    // Store settings
    (*instance)->settings = malloc(sizeof(struct up_settings));
    if (!(*instance)->settings) {
        free(*instance);
        HPD_LOG_RETURN_E_ALLOC(context);
    }
    memcpy((*instance)->settings, settings, sizeof(struct up_settings));

    // Set state
    (*instance)->state = S_START;
    (*instance)->buffer = NULL;

    // Set pointers
    (*instance)->protocol = 0;
    (*instance)->protocol_l = 0;
    (*instance)->host = 0;
    (*instance)->host_l = 0;
    (*instance)->port = 0;
    (*instance)->port_l = 0;
    (*instance)->path = 0;
    (*instance)->path_l = 0;
    (*instance)->key_value = 0;
    (*instance)->end = 0;
    (*instance)->last_key = 0;
    (*instance)->last_key_l = 0;
    (*instance)->last_value = 0;
    (*instance)->last_value_l = 0;
    (*instance)->last_path = 0;
    (*instance)->last_path_l = 0;
    (*instance)->parser = 0;
    (*instance)->insert = 0;

    // Store data
    (*instance)->data = data;

    return HPD_E_SUCCESS;
}

hpd_error_t up_destroy(struct up *instance)
{
    if (!instance) return HPD_E_NULL;

    if(instance->settings) free(instance->settings);
    if(instance->buffer) free(instance->buffer);
    free(instance);

    return HPD_E_SUCCESS;
}

static int up_isLegalURLChar(char c)
{
    if ((c >= '0' && c <= '9') ||
        (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
        c == '-' || c == '.' || c == '_' || c == '~' || c == ':' ||
        c == '/' || c == '?' || c == '#' || c == '[' || c == ']' ||
        c == '@' || c == '!' || c == '$' || c == '&' || c == '\'' ||
        c == '(' || c == ')' || c == '*' || c == '+' || c == ',' ||
        c == ';' || c == '=' || c == '%')
        return 1;

    return 0;
}

#define UP_CALL(X, ...) do { \
    hpd_error_t rc; \
    if (settings->X != NULL) { \
        if ((rc = settings->X(instance->data, ##__VA_ARGS__))) { \
            instance->state = S_ERROR; \
            return rc; \
        } \
    } \
} while(0)

hpd_error_t up_add_chunk(struct up *instance, const char *chunk, size_t len)
{
    if (!instance || !chunk) return HPD_E_NULL;

    const struct up_settings *settings = instance->settings;
    char *buffer;

    // Add chunk to buffer
    instance->end += len;
    buffer = realloc(instance->buffer, instance->end * sizeof(char));
    if (!buffer) {
        instance->state = S_ERROR;
        HPD_LOG_RETURN_E_ALLOC(instance->context);
        return HPD_E_ALLOC;
    }
    instance->buffer = buffer;
    memcpy(&buffer[instance->insert], chunk, len);
    instance->insert += len;

    // Parse the new chunk in buffer
    for(; instance->parser < instance->end; instance->parser++)
    {
        char c = instance->buffer[instance->parser];

        // Check if it is a valid URL char. If not, print an error message
        // and set parser to error state
        if (!up_isLegalURLChar(c))
        {
            instance->state = S_ERROR;
            HPD_LOG_RETURN(instance->context, HPD_E_ARGUMENT, "Invalid character ('%c') in URL.", c);
        }

        switch(instance->state)
        {
            case S_START:
                UP_CALL(on_begin);
                if (c == '/') {
                    instance->state = S_SEGMENT;
                    instance->path = instance->parser;
                    instance->path_l++;
                    instance->last_path = instance->parser + 1;
                } else {
                    instance->state = S_PROTOCOL;
                    instance->protocol = instance->parser;
                    instance->protocol_l++;
                }
                break;
            case S_PROTOCOL:
                if (c == ':') {
                    UP_CALL(on_protocol, &instance->buffer[instance->protocol], instance->parser - instance->protocol);
                    instance->state = S_SLASH1;
                } else {
                    instance->protocol_l++;
                }
                break;
            case S_SLASH1:
                if(c == '/') {
                    instance->state = S_SLASH2;
                } else {
                    instance->state = S_ERROR;
                    HPD_LOG_RETURN(instance->context, HPD_E_ARGUMENT, "URL Parse error.");
                }
                break;
            case S_SLASH2:
                if(c == '/') {
                    instance->state = S_HOST;
                    instance->host = instance->parser + 1;
                } else {
                    instance->state = S_ERROR;
                    HPD_LOG_RETURN(instance->context, HPD_E_ARGUMENT, "URL Parse error.");
                }
                break;
            case S_HOST:
                if(c == ':' || c == '/') {
                    UP_CALL(on_host, &instance->buffer[instance->host], instance->host_l);
                    if (c == ':') instance->state = S_PREPORT;
                    if (c == '/') {
                        instance->state = S_SEGMENT;
                        instance->path = instance->parser;
                        instance->path_l++;
                        instance->last_path = instance->parser + 1;
                    }
                    break;
                } else {
                    instance->host_l++;
                }
                break;
            case S_PREPORT:
                if(c == '/') {
                    instance->state = S_ERROR;
                    HPD_LOG_RETURN(instance->context, HPD_E_ARGUMENT, "URL Parse error.");
                }
                instance->state = S_PORT;
                instance->port = instance->parser;
                instance->port_l++;
                break;
            case S_PORT:
                if (c == '/')
                {
                    UP_CALL(on_port, &instance->buffer[instance->port], instance->port_l);
                    instance->state = S_SEGMENT;
                    instance->path = instance->parser;
                    instance->path_l++;
                    instance->last_path = instance->parser + 1;
                } else {
                    instance->port_l++;
                }
                break;
            case S_SEGMENT:
                if (c == '/' || c == '?') {
                    UP_CALL(on_path_segment, &instance->buffer[instance->last_path], instance->last_path_l);
                    instance->last_path = instance->parser + 1;
                    instance->last_path_l = 0;
                } else {
                    instance->last_path_l++;
                }
                if (c == '?') {
                    UP_CALL(on_path_complete, &instance->buffer[instance->path], instance->path_l);
                    instance->state = S_KEY;
                    instance->key_value = instance->parser + 1;
                    instance->last_key = instance->parser + 1;
                } else {
                    instance->path_l++;
                }
                break;
            case S_KEY:
                if (c == '=') {
                    instance->state = S_VALUE;
                    instance->last_value = instance->parser + 1;
                    instance->last_value_l = 0;
                } else {
                    instance->last_key_l++;
                }
                break;
            case S_VALUE:
                if (c == '&') {
                    UP_CALL (on_key_value, &instance->buffer[instance->last_key], instance->last_key_l, &instance->buffer[instance->last_value], instance->last_value_l);
                    instance->state = S_KEY;
                    instance->last_key = instance->parser + 1;
                    instance->last_key_l = 0;
                } else {
                    instance->last_value_l++;
                }
                break;

            case S_ERROR:
                HPD_LOG_RETURN(instance->context, HPD_E_STATE, "URL Parser in error state.");
            default:
                HPD_LOG_RETURN(instance->context, HPD_E_STATE, "Unexpected state.");
        }
    }

    return HPD_E_SUCCESS;
}

hpd_error_t up_complete(struct up *instance)
{
    if (!instance) return HPD_E_NULL;

    const struct up_settings *settings = instance->settings;

    // Check if we need to send a last chunk and that we are in a valid
    // end state
    switch(instance->state)
    {
        case S_SEGMENT:
            UP_CALL(on_path_segment, &instance->buffer[instance->last_path], instance->last_path_l);
            UP_CALL (on_path_complete, &instance->buffer[instance->path], instance->path_l);
            break;
        case S_VALUE:
            UP_CALL (on_key_value, &instance->buffer[instance->last_key], instance->last_key_l, &instance->buffer[instance->last_value], instance->last_value_l);
            break;
        case S_HOST:
            UP_CALL(on_host, &instance->buffer[instance->host], instance->host_l);
            break;
        case S_PORT:
            UP_CALL(on_port, &instance->buffer[instance->port], instance->port_l);
            break;
        default:
            HPD_LOG_RETURN(instance->context, HPD_E_STATE, "Unexpected state.");
    }

    UP_CALL(on_complete, instance->buffer, instance->parser);
    return HPD_E_SUCCESS;
}