/Users/maurits/Documents/studie/afstuderen/biosphere/common/type.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: mar 20, 2007
 * 
 * Function:
 * Utility functions for use with Bio-SPHERE data structures.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */
 
#include "type.h"
#include "str.h"
#include <alloc.h>

#include <assert.h>
#include <apr_pools.h>
#include <apr_strings.h>
#include <stdarg.h>
#include <stdlib.h>
#include <errno.h>


bs_data_type *new_bs_data_type(apr_pool_t *mp, const char *name)
{
        bs_data_type *ret = apr_pcalloc(mp, sizeof(bs_data_type));
        if (!ret) return NULL;
        
        ret->name = apr_pstrdup(mp, name);
        ret->builtin = is_builtin_type(name);
        ret->from_mp = TRUE;
        return ret;
}


bs_message *new_bs_message(apr_pool_t *mp, const char *name, bs_uint16 num_parts)
{
        bs_message *ret = apr_pcalloc(mp, sizeof(bs_message));
        if (!ret) return NULL;
        
        ret->name = apr_pstrdup(mp, name);
        ret->from_mp = TRUE;
        if (num_parts > 0) {
                ret->num_parts = num_parts;
                ret->parts = (bs_message_part **) apr_pcalloc(mp,
                                sizeof(bs_message_part *) * num_parts);
        }
        return ret;
}


inline void add_part_to_message(bs_message *msg, bs_message_part *part, apr_pool_t *mp)
{
        int orig_size;
        assert(msg && part);
        
        orig_size = msg->num_parts * sizeof(bs_message_part *);
        msg->parts = pool_realloc(msg->parts, orig_size,
                        orig_size + sizeof(bs_message_part *), mp);
        msg->parts[msg->num_parts++] = part;
}


bs_message_part *new_bs_message_part(apr_pool_t *mp, const char *name,
                bs_data_type *type)
{
        bs_message_part *ret = apr_pcalloc(mp, sizeof(bs_message_part));
        if (!ret) return NULL;
        
        ret->name = apr_pstrdup(mp, name);
        ret->type = type;
        ret->from_mp = TRUE;
        return ret;
}
                
                
bs_operation *new_bs_operation(apr_pool_t *mp, const char *name,
                bs_message *input, bs_message *output, bs_message *fault)
{
        bs_operation *ret = apr_pcalloc(mp, sizeof(bs_operation));
        if (!ret) return NULL;
        
        ret->name = apr_pstrdup(mp, name);
        ret->input = input;
        ret->output = output;
        ret->fault = fault;
        ret->from_mp = TRUE;
        return ret;
}
                

bs_port_type *new_bs_port_type(apr_pool_t *mp, const char *name,
                bs_uint16 num_operations)
{
        bs_port_type *ret = apr_pcalloc(mp, sizeof(bs_port_type));
        if (!ret) return NULL;
        
        ret->name = apr_pstrdup(mp, name);
        ret->from_mp = TRUE;
        if (num_operations > 0) {
                ret->num_operations = num_operations;
                ret->operations = (bs_operation **) apr_pcalloc(mp,
                                sizeof(bs_operation *) * num_operations);
        }
        return ret;
}


inline void add_operation_to_port_type(bs_port_type *pt, bs_operation *op,
                apr_pool_t *mp)
{
        int orig_size;
        assert(pt && op);
        
        orig_size = pt->num_operations * sizeof(bs_operation *);
        pt->operations = pool_realloc(pt->operations, orig_size,
                        orig_size + sizeof(bs_operation *), mp);
        pt->operations[pt->num_operations++] = op;
}


bs_port *new_bs_port(apr_pool_t *mp, const char *name, bs_port_type *type)
{
        bs_port *ret = apr_pcalloc(mp, sizeof(bs_port));
        if (!ret) return NULL;
        
        ret->name = apr_pstrdup(mp, name);
        ret->port_type = type;
        ret->from_mp = TRUE;
        return ret;
}


bs_service *new_bs_service(apr_pool_t *mp, const char *name,
                bs_uint16 num_ports)
{
        bs_service *ret = apr_pcalloc(mp, sizeof(bs_service));
        if (!ret) return NULL;
        
        ret->name = apr_pstrdup(mp, name);
        ret->from_mp = TRUE;
        if (num_ports > 0) {
                ret->num_ports = num_ports;
                ret->ports = (bs_port **) apr_pcalloc(mp,
                                sizeof(bs_port *) * num_ports);
        }
        return ret;
}


inline void add_port_to_service(bs_service *svc, bs_port *port,
                apr_pool_t *mp)
{
        int orig_size;
        assert(svc && port);
        
        orig_size = svc->num_ports * sizeof(bs_port *);
        svc->ports = pool_realloc(svc->ports, orig_size,
                        orig_size + sizeof(bs_port *), mp);
        svc->ports[svc->num_ports++] = port;
}


bs_definition *new_bs_definition(apr_pool_t *mp, const char *name,
                bs_uint16 num_data_types, bs_uint16 num_messages,
                bs_uint16 num_port_types, bs_uint16 num_services)
{
        bs_definition *ret = apr_pcalloc(mp, sizeof(bs_definition));
        if (!ret) return NULL;
        
        ret->name = apr_pstrdup(mp, name);
        ret->from_mp = TRUE;
        if (num_data_types > 0) {
                ret->num_data_types = num_data_types;
                ret->data_types = (bs_data_type **) apr_pcalloc(mp,
                                sizeof(bs_data_type *) * num_data_types);
        }
        if (num_messages > 0) {
                ret->num_messages = num_messages;
                ret->messages = (bs_message **) apr_pcalloc(mp,
                                sizeof(bs_message *) * num_messages);
        }
        if (num_port_types > 0) {
                ret->num_port_types = num_port_types;
                ret->port_types = (bs_port_type **) apr_pcalloc(mp,
                                sizeof(bs_port_type *) * num_port_types);
        }
        if (num_services > 0) {
                ret->num_services = num_services;
                ret->services = (bs_service **) apr_pcalloc(mp,
                                sizeof(bs_service *) * num_services);
        }
        return ret;
}


inline void add_data_type_to_definition(bs_definition *def, bs_data_type *type,
                apr_pool_t *mp)
{
        int orig_size;
        bs_uint16 i;
        assert(def && type);
        
        /* Check if the data types isn't already in the def: */
        for (i = 0; i < def->num_data_types; i++) {
                bs_data_type *t = def->data_types[i];
                if (streq(type->name, t->name)) return;
        }
        
        /* Reallocate space and add: */
        orig_size = def->num_data_types * sizeof(bs_data_type *);
        def->data_types = pool_realloc(def->data_types, orig_size,
                        orig_size + sizeof(bs_data_type *), mp);
        def->data_types[def->num_data_types++] = type;
}


inline void add_message_to_definition(bs_definition *def, bs_message *msg,
                apr_pool_t *mp)
{
        int orig_size;
        bs_uint16 i;
        assert(def && msg);
        
        /* Check if the message isn't already in the def: */
        for (i = 0; i < def->num_messages; i++) {
                bs_message *m = def->messages[i];
                if (streq(msg->name, m->name)) return;
        }
        
        /* Reallocate space and add: */
        orig_size = def->num_messages * sizeof(bs_message *);
        def->messages = pool_realloc(def->messages, orig_size,
                        orig_size + sizeof(bs_message *), mp);
        def->messages[def->num_messages++] = msg;
}


inline void add_port_type_to_definition(bs_definition *def, bs_port_type *pt,
                apr_pool_t *mp)
{
        int orig_size;
        bs_uint16 i;
        assert(def && pt);
        
        /* Check if the port types isn't already in the def: */
        for (i = 0; i < def->num_port_types; i++) {
                bs_port_type *p = def->port_types[i];
                if (streq(pt->name, p->name)) return;
        }
        
        /* Reallocate space and add: */
        orig_size = def->num_port_types * sizeof(bs_port_type *);
        def->port_types = pool_realloc(def->port_types, orig_size,
                        orig_size + sizeof(bs_port_type *), mp);
        def->port_types[def->num_port_types++] = pt;
}


inline void add_service_to_definition(bs_definition *def, bs_service *svc,
                apr_pool_t *mp)
{
        int orig_size;
        bs_uint16 i;
        assert(def && svc);
        
        /* Check if the service isn't already in the def: */
        for (i = 0; i < def->num_services; i++) {
                bs_service *s = def->services[i];
                if (streq(svc->name, s->name)) return;
        }
        
        /* Reallocate space and add: */
        orig_size = def->num_services * sizeof(bs_service *);
        def->services = pool_realloc(def->services, orig_size,
                        orig_size + sizeof(bs_service *), mp);
        def->services[def->num_services++] = svc;
}


bs_service_request *new_bs_service_request(apr_pool_t *mp, bs_byte *uuid,
                char *service, char *port, char *operation,
                bs_message_instance *input)
{
        unsigned i;
        bs_service_request *req;
        
        req = apr_pcalloc(mp, sizeof(bs_service_request));
        for (i = 0; i < 16; i++) req->uuid[i] = uuid[i];
        
        if (service) req->service = apr_pstrdup(mp, service);
        if (port) req->port = apr_pstrdup(mp, port);
        if (operation) req->operation = apr_pstrdup(mp, operation);
        req->input = input;
        req->from_mp = TRUE;
        return req;
}


bs_service_response *new_bs_service_response(apr_pool_t *mp,
                const bs_byte *uuid,
                const char *service, const char *port, const char *operation,
                bs_message_instance *output, bs_message_instance *fault)
{
        unsigned i;
        bs_service_response *resp;
        
        resp = apr_pcalloc(mp, sizeof(bs_service_response));
        for (i = 0; i < 16; i++) resp->uuid[i] = uuid[i];
        resp->service = apr_pstrdup(mp, service);
        resp->port = apr_pstrdup(mp, port);
        resp->operation = apr_pstrdup(mp, operation);
        resp->output = output;
        resp->fault = fault;
        resp->from_mp = TRUE;
        return resp;
}


bs_message_instance *new_bs_message_instance(apr_pool_t *mp, const char *name,
                const bs_uint16 num_parts)
{
        bs_message_instance *ret;
        
        ret = apr_pcalloc(mp, sizeof(bs_message_instance));
        ret->name = apr_pstrdup(mp, name);
        if (num_parts > 0) {
                ret->num_parts = num_parts;
                ret->parts = apr_pcalloc(mp, num_parts * sizeof(bs_part_instance *));
        }
        ret->from_mp = TRUE;
        return ret;
}


bs_part_instance *new_bs_part_instance(apr_pool_t *mp, const char *name,
                bs_data_type *type, const char *data, bs_uint64 size)
{
        bs_part_instance *ret;
        ret = apr_pcalloc(mp, sizeof(bs_part_instance));
        ret->name = apr_pstrdup(mp, name);
        ret->type = type;
        ret->data = apr_pstrndup(mp, data, size);
        ret->size = size;
        ret->from_mp = TRUE;
        return ret;
}


inline void add_part_to_request_instance(bs_part_instance *part,
                bs_message_instance *msg, apr_pool_t *mp)
{
        bs_uint16 orig_size;
        assert(msg && part);
        
        orig_size = msg->num_parts * sizeof(bs_part_instance *);
        msg->parts = pool_realloc(msg->parts, orig_size,
                        orig_size + sizeof(bs_part_instance *), mp);
        msg->parts[msg->num_parts++] = part;
}


bs_status merge_def_with_def(apr_pool_t *mp, bs_definition *result,
                bs_definition *d)
{
        bs_uint16 i;

        for (i = 0; i < d->num_data_types; i++)
                add_data_type_to_definition(result, d->data_types[i], mp);

        for (i = 0; i < d->num_messages; i++)
                add_message_to_definition(result, d->messages[i], mp);

        for (i = 0; i < d->num_port_types; i++)
                add_port_type_to_definition(result, d->port_types[i], mp);

        for (i = 0; i < d->num_services; i++)
                add_service_to_definition(result, d->services[i], mp);
        
        return BS_OK;
}


bs_status merge_bs_definitions(apr_pool_t *mp, bs_definition **def, ...)
{
        va_list argptr;
        bs_definition *d, *result;
        
        result = new_bs_definition(mp, "service_definitions", 0, 0, 0, 0);
        
        va_start(argptr, def);
        while ((d = va_arg(argptr, bs_definition *)) != NULL) {
                bs_status rv = merge_def_with_def(mp, result, d);
                if (rv != BS_OK) {
                        va_end(argptr);
                        return BS_ERROR;        
                }
        }
        va_end(argptr);
        
        *def = result;
        return BS_OK;
}


bs_bool is_builtin_type(const char *name)
{
        if (streq(name, "bs_bool"))        return TRUE;
        else if (streq(name, "bs_string")) return TRUE;
        else if (streq(name, "bs_byte"))   return TRUE;
        else if (streq(name, "bs_int16"))  return TRUE;
        else if (streq(name, "bs_uint16")) return TRUE;
        else if (streq(name, "bs_int32"))  return TRUE;
        else if (streq(name, "bs_uint32")) return TRUE;
        else if (streq(name, "bs_int64"))  return TRUE;
        else if (streq(name, "bs_uint64")) return TRUE;
        else if (streq(name, "bs_double")) return TRUE;
        else return FALSE;      
}


static inline bs_status check_builtin_type_bs_bool(bs_part_instance *inst)
{
        /* The data should be either true or false, 0 or 1 (case insensitive): */
        if (apr_strnatcasecmp(inst->data, "true") == 0) return BS_OK;
        else if (apr_strnatcasecmp(inst->data, "false") == 0) return BS_OK;
        if (apr_strnatcasecmp(inst->data, "1") == 0) return BS_OK;
        else if (apr_strnatcasecmp(inst->data, "0") == 0) return BS_OK;
        else return BS_TYPE_NO_BOOLEAN;
}


static inline bs_status check_builtin_type_bs_string(bs_part_instance *inst)
{
        /* A string can be anything, make sure it is null-terminated. */
        if (inst->data[inst->size] != '\0') return BS_TYPE_STRING_NO_TERM; 
        return BS_OK;
}


static inline bs_status check_builtin_type_bs_byte(bs_part_instance *inst)
{
        /* The length should be 1: */
        if (inst->size != 1) return BS_TYPE_BYTE_ERROR;
        return BS_OK;
}


static inline bs_status check_builtin_type_bs_int16(bs_part_instance *inst)
{
        apr_int64_t num;
        char *end;
        
        /* A int16 has a maxium value of 32767 and lower value of -32767: */
        if (inst->size > 6) return BS_ERROR;
        num = apr_strtoi64(inst->data, &end, 0);
        if (num > 32767 || num < -32767) return BS_ERROR;
        return BS_OK;
}


static inline bs_status check_builtin_type_bs_uint16(bs_part_instance *inst)
{
        apr_int64_t num;
        char *end;
        
        /* A uint16 has a maxium value of 65535: */
        if (inst->size > 6) return BS_ERROR;
        num = apr_strtoi64(inst->data, &end, 0);
        if (num > 65535) return BS_ERROR;
        return BS_OK;
}


static inline bs_status check_builtin_type_bs_int32(bs_part_instance *inst)
{
        apr_int64_t num;
        char *end;
        
        /* A int32 has a maxium value of 2147483647 and lower value of -2147483647: */
        if (inst->size > 11) return BS_ERROR;
        num = apr_strtoi64(inst->data, &end, 0);
        if (num > 2147483647 || num < -2147483647) return BS_ERROR;
        return BS_OK;
}


static inline bs_status check_builtin_type_bs_uint32(bs_part_instance *inst)
{
        apr_int64_t num;
        char *end;
        
        /* A int32 has a maxium value of 4294967295: */
        if (inst->size > 11) return BS_ERROR;
        num = apr_strtoi64(inst->data, &end, 0);
        if (num > 0xffffffff) return BS_ERROR;
        return BS_OK;
}


static inline bs_status check_builtin_type_bs_int64(bs_part_instance *inst)
{
        bs_int64 num;
        char *end;
        
        num = apr_strtoi64(inst->data, &end, 0);
        if (errno == ERANGE) return BS_TYPE_RANGE;
        return BS_OK;
}


static inline bs_status check_builtin_type_bs_uint64(bs_part_instance *inst)
{
        bs_int64 num;
        char *end;
        
        num = apr_strtoi64(inst->data, &end, 0);
        if (errno == ERANGE) return BS_TYPE_RANGE;
        if (num < 0) return BS_TYPE_RANGE;
        return BS_OK;
}


static inline bs_status check_builtin_type_bs_double(bs_part_instance *inst)
{
        bs_double num;
        char *end;
        
        if (inst->size > 15) return BS_TYPE_CONVERT_ERROR;
        
        num = strtod(inst->data, &end);
        if (errno == EINVAL) return BS_TYPE_CONVERT_ERROR;
        if (errno == ERANGE) return BS_TYPE_RANGE;
        return BS_OK;
}


bs_status check_builtin_type(bs_part_instance *inst)
{
        bs_data_type *type = inst->type;
        
        if (streq(type->name, "bs_bool"))
                return check_builtin_type_bs_bool(inst);
        else if (streq(type->name, "bs_string"))
                return check_builtin_type_bs_string(inst);
        else if (streq(type->name, "bs_byte"))
                return check_builtin_type_bs_byte(inst);
        else if (streq(type->name, "bs_int16"))
                return check_builtin_type_bs_int16(inst);
        else if (streq(type->name, "bs_uint16"))
                return check_builtin_type_bs_uint16(inst);
        else if (streq(type->name, "bs_int32"))
                return check_builtin_type_bs_int32(inst);
        else if (streq(type->name, "bs_uint32"))
                return check_builtin_type_bs_uint32(inst);
        else if (streq(type->name, "bs_int64"))
                return check_builtin_type_bs_int64(inst);
        else if (streq(type->name, "bs_uint64"))
                return check_builtin_type_bs_uint64(inst);
        else if (streq(type->name, "bs_double"))
                return check_builtin_type_bs_double(inst);
        else
                return BS_ERROR;
}


static bs_bool compare_message_parts(const bs_part_instance *inst,
                bs_message_part *def)
{
        if (!streq(inst->name, def->name)) return FALSE;
        if (!streq(inst->type->name, def->type->name)) return FALSE;
        return TRUE;
}


static bs_bool can_service_parts(const bs_service_request *request,
                const bs_operation *operation)
{
        unsigned i;
        
        /* Both the request and the definition should have equal parts: */
        if (request->input->num_parts != operation->input->num_parts)
                return FALSE;
        
        /* We do a pairwise comparison of parts: */
        for (i = 0; i < request->input->num_parts; i++) {
                if (!compare_message_parts(request->input->parts[i],
                                operation->input->parts[i])) return FALSE;      
        }
        return TRUE;
}


static bs_bool can_service(const bs_service_request *request,
                const bs_definition *def)
{
        unsigned i;
        bs_service *svc = NULL;
        bs_port_type *pt = NULL;
        
        /* Check if the named service is in the definition: */
        for (i = 0; i < def->num_services; i++)
                if (streq(request->service, def->services[i]->name))
                        break;
        if (i == def->num_services) return FALSE;
        
        /* Check if the named port is in the service: */
        svc = def->services[i];
        for (i = 0; i < svc->num_ports; i++)
                if (streq(request->port, svc->ports[i]->name))
                        break;
        if (i == svc->num_ports) return FALSE;
        
        /* Check if the named operation is in the porttype of the port: */
        pt = svc->ports[i]->port_type;
        for (i = 0; i < pt->num_operations; i++)
                if (streq(request->operation, pt->operations[i]->name))
                        break;
        if (i == pt->num_operations) return FALSE;
        
        /* Check message parts: */
        return can_service_parts(request, pt->operations[i]);
}


static bs_status check_types(const bs_service_request *request)
{
        bs_uint16 i;
        for (i = 0; i < request->input->num_parts; i++) {
                bs_part_instance *inst = request->input->parts[i];
                if (is_builtin_type(inst->type->name) && check_builtin_type(inst) != BS_OK)
                        return BS_ERROR;
        }
        return BS_OK;
}


bs_bool request_corresponds_with_definition(const bs_service_request *request,
                const bs_definition *def)
{
        /* Check whether the request's service, port and operation are listed in the def: */
        /* Check if the data types in the request match with the definition: */
        if (!can_service(request, def)) return FALSE;
        
        /* Check the if data types instances are correct: */
        if (check_types(request) != BS_OK) return FALSE;
        
        return TRUE;    
}

---