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

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: feb 20, 2007
 * 
 * Function:
 * XML translation for different Bio-SPHERE 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 "xml.h"
#include "str.h"
#include "type.h"
#include <alloc.h>
#include <stack.h>

#include <apr_base64.h>
#include <apr_strings.h>
#include <apr_xml.h>
#include <apr_uuid.h>
#include <assert.h>
#include <string.h>
#include <stdio.h>


/*******************************************************
 *                                                     *
 *  SERVICE DEFINITION TO XML HELPER FUNCTIONS         *
 *                                                     *
 *******************************************************/

static bs_status add_datatypes_to_xml(char **buf, const bs_definition *def,
                apr_pool_t *mp)
{
        bs_uint16 i;
        char *collect = "";
        
        for (i = 0; i < def->num_data_types; i++) {
                char *tmp;
                bs_data_type *type = def->data_types[i];
                tmp = apr_psprintf(mp, "<type name=\"%s\" />", type->name);
                collect = apr_pstrcat(mp, collect, tmp, NULL);
        }
        
        *buf = apr_pstrcat(mp, *buf, collect, NULL);
        return BS_OK;
}


static bs_status add_message_part_to_xml(char **buf,
                const bs_message_part *part, apr_pool_t *mp)
{
        char *collect = apr_psprintf(mp, "<part name=\"%s\" type=\"%s\"/>",
                        part->name, part->type->name);
        *buf = apr_pstrcat(mp, *buf, collect, NULL);
        return BS_OK;
}


static bs_status add_message_to_xml(char **buf, const bs_message *msg,
                apr_pool_t *mp)
{
        bs_status rv;
        int i;
        char *collect = apr_psprintf(mp, "<message name=\"%s\">", msg->name);
        
        for (i = 0; i < msg->num_parts; i++) {
                rv = add_message_part_to_xml(&collect, msg->parts[i], mp);
                if (rv != BS_OK) return rv;
        }
        
        *buf = apr_pstrcat(mp, *buf, collect, "</message>", NULL);
        return BS_OK;
}


static bs_status add_messages_to_xml(char **buf, const bs_definition *def,
                apr_pool_t *mp)
{
        int i;
        bs_status rv;
        
        for (i = 0; i < def->num_messages; i++) {
                rv = add_message_to_xml(buf, def->messages[i], mp);
                if (rv != BS_OK) return rv;
        }
                
        return BS_OK;
}


static bs_status add_operation_to_xml(char **buf, const bs_operation *op,
                apr_pool_t *mp)
{
        char *i = "", *o = "", *f = "";
        char *collect = apr_psprintf(mp, "<operation name=\"%s\">", op->name);
        
        if (op->input)
                i = apr_psprintf(mp, "<input message=\"%s\"/>", op->input->name);
        if (op->output)
                o = apr_psprintf(mp, "<output message=\"%s\"/>", op->output->name);
        if (op->fault)
                f = apr_psprintf(mp, "<fault message=\"%s\"/>", op->fault->name);
        
        *buf = apr_pstrcat(mp, *buf, collect, i, o, f, "</operation>", NULL);
        return BS_OK;   
}


static bs_status add_port_type_to_xml(char **buf, const bs_port_type *pt,
                apr_pool_t *mp)
{
        bs_status rv;
        unsigned i;
        char *collect = "";
        
        collect = apr_psprintf(mp, "<portType name=\"%s\">", pt->name);
        
        for (i = 0; i < pt->num_operations; i++) {
                rv = add_operation_to_xml(&collect, pt->operations[i], mp);
                if (rv != BS_OK) return rv;
        }
        
        *buf = apr_pstrcat(mp, *buf, collect, "</portType>", NULL);
        return BS_OK;   
}


static bs_status add_porttypes_to_xml(char **buf, const bs_definition *def,
                apr_pool_t *mp)
{
        int i;
        bs_status rv;
        
        for (i = 0; i < def->num_port_types; i++) {
                rv = add_port_type_to_xml(buf, def->port_types[i], mp);
                if (rv != BS_OK) return rv;
        }

        return BS_OK;
}


static bs_status add_port_to_xml(char **buf, const bs_port *port,
                apr_pool_t *mp)
{
        char *collect = apr_psprintf(mp, "<port name=\"%s\" type=\"%s\" />",
                        port->name, port->port_type->name);
        *buf = apr_pstrcat(mp, *buf, collect, NULL);
        return BS_OK;   
}


static bs_status add_service_to_xml(char **buf, const bs_service *sv,
                apr_pool_t *mp)
{
        bs_status rv;
        unsigned i;
        char *collect = apr_psprintf(mp, "<service name=\"%s\">", sv->name);
                        
        /* Add the ports of the service: */
        for (i = 0; i < sv->num_ports; i++) {
                rv = add_port_to_xml(&collect, sv->ports[i], mp);
                if (rv != BS_OK) return rv;     
        }
        
        *buf = apr_pstrcat(mp, *buf, collect, "</service>", NULL);
        return BS_OK;   
}


static bs_status add_services_to_xml(char **buf, const bs_definition *def,
                apr_pool_t *mp)
{
        unsigned i;
        bs_status rv;
        
        for (i = 0; i < def->num_services; i++) {
                rv = add_service_to_xml(buf, def->services[i], mp);
                if (rv != BS_OK) return rv;
        }

        return BS_OK;
}


/*******************************************************
 *                                                     *
 *  SERVICE REQUEST TO XML HELPER FUNCTIONS            *
 *                                                     *
 *******************************************************/

static bs_status add_use_service_to_xml(char **buf, const bs_service_request *def,
                apr_pool_t *mp)
{
        char *collect = apr_psprintf(mp,
                        "<use service=\"%s\" port=\"%s\" operation=\"%s\" />",
                        def->service, def->port, def->operation);
        *buf = apr_pstrcat(mp, *buf, collect, NULL);
        return BS_OK;
}


static bs_status add_part_instance_to_xml(char **buf, const bs_part_instance *def,
                apr_pool_t *mp)
{
        char *tmp, *data64;
        tmp = apr_psprintf(mp, "<part name=\"%s\" type=\"%s\" size=\"%" BS_UINT64_FMT "\">", def->name,
                        def->type->name, def->size);
        
        /* Convert the data to base64 encoding if necessary: */
        if (def->type->builtin) data64 = def->data;
        else {
                data64 = apr_pcalloc(mp, apr_base64_encode_len(def->size) + 1);
            apr_base64_encode(data64, def->data, def->size);
        }
        
        *buf = apr_pstrcat(mp, *buf, tmp, data64, "</part>", NULL);
        return BS_OK;           
}


static bs_status add_message_instance_to_xml(char **buf, const bs_message_instance *def,
                char *type, apr_pool_t *mp)
{
        bs_status rv;
        unsigned i;
        char *tmp, *tmp2, *collect = "";
        tmp = apr_psprintf(mp, "<%s message=\"%s\">", type, def->name);
                        
        /* Add the ports of the service: */
        for (i = 0; i < def->num_parts; i++) {
                rv = add_part_instance_to_xml(&collect, def->parts[i], mp);
                if (rv != BS_OK) return rv;     
        }
        
        tmp2 = apr_psprintf(mp, "</%s>", type);
        *buf = apr_pstrcat(mp, *buf, tmp, collect, tmp2, NULL);
        return BS_OK;   
}


/*******************************************************
 *                                                     *
 *  SERVICE RESPONSE TO XML HELPER FUNCTIONS           *
 *                                                     *
 *******************************************************/

static bs_status add_used_service_to_xml(char **buf, const bs_service_response *def,
                apr_pool_t *mp)
{
        char *collect = apr_psprintf(mp,
                        "<used service=\"%s\" port=\"%s\" operation=\"%s\" />",
                        def->service, def->port, def->operation);
        *buf = apr_pstrcat(mp, *buf, collect, NULL);
        return BS_OK;
}


/*******************************************************
 *                                                     *
 *  MAIN TO XML FUNCTIONS                              *
 *                                                     *
 *******************************************************/

bs_status xlate_definition_to_xml(char **buf, bs_uint64 *size,
                const bs_definition *def, apr_pool_t *mp)
{
        char *collect = apr_psprintf(mp, "<definitions name=\"%s\">", def->name);
        add_datatypes_to_xml(&collect, def, mp);
        add_messages_to_xml(&collect, def, mp);
        add_porttypes_to_xml(&collect, def, mp);
        add_services_to_xml(&collect, def, mp);
        *buf = apr_pstrcat(mp, collect, "</definitions>", NULL);
        *size = strlen(*buf);
        return BS_OK;
}


bs_status xlate_request_to_xml(char **buf, bs_uint64 *size,
                const bs_service_request *def, apr_pool_t *mp)
{
        char *collect, uuid_format[APR_UUID_FORMATTED_LENGTH + 1];
        
        /* Create (null-terminated) UUID for the request: */
        uuid_format[APR_UUID_FORMATTED_LENGTH] = '\0';
        apr_uuid_format(uuid_format, (apr_uuid_t *) &def->uuid);
        collect = apr_psprintf(mp, "<request uuid=\"%s\">", uuid_format);
        
        add_use_service_to_xml(&collect, def, mp);
        add_message_instance_to_xml(&collect, def->input, "input", mp);
        
        *buf = apr_pstrcat(mp, collect, "</request>", NULL);
        *size = strlen(*buf);
        return BS_OK;   
}


bs_status xlate_response_to_xml(char **buf, bs_uint64 *size,
                const bs_service_response *def, apr_pool_t *mp)
{
        char *collect, uuid_format[APR_UUID_FORMATTED_LENGTH + 1];
        
        /* Create (null-terminated) UUID for the request: */
        uuid_format[APR_UUID_FORMATTED_LENGTH] = '\0';
        apr_uuid_format(uuid_format, (apr_uuid_t *) &def->uuid);
        collect = apr_psprintf(mp, "<response uuid=\"%s\">", uuid_format);
        
        add_used_service_to_xml(&collect, def, mp);
        if (def->output)
                add_message_instance_to_xml(&collect, def->output, "output", mp);
        if (def->fault)
                add_message_instance_to_xml(&collect, def->fault, "fault", mp);
        
        *buf = apr_pstrcat(mp, collect, "</response>", NULL);
        *size = strlen(*buf);
        return BS_OK;   
}


/*******************************************************
 *                                                     *
 *  SERVICE DEFINITION FROM XML HELPER FUNCTIONS       *
 *                                                     *
 *******************************************************/

static bs_data_type *process_data_type(const apr_xml_elem *type, apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        bs_data_type *ret = NULL;
        
        /* Process data type name attribute and allocate bs_data_type structure: */
        for (attr = type->attr; attr; attr = attr->next) {
                if (streq(attr->name, "name")) {
                        ret = new_bs_data_type(mp, attr->value);
                        break;
                }
        }
        
        return ret;
}


static bs_data_type *lookup_data_type_by_name(const bs_definition *def, const char *name)
{
        /* Look for the datatype by its name in the given definition def: */
        bs_uint16 i;
        for (i = 0; i < def->num_data_types; i++) {
                bs_data_type *type = def->data_types[i];
                if (streq(type->name, name)) return type;       
        }
        return NULL;    
}


static bs_message *process_message(const apr_xml_elem *msg, bs_definition *def,
                apr_pool_t *mp)
{
        const apr_xml_elem *part;
        const apr_xml_attr *attr;
        bs_message *m = NULL;
        
        /* Process message name attribute and allocate bs_message structure: */
        for (attr = msg->attr; attr; attr = attr->next)
                if (streq(attr->name, "name"))
                        m = new_bs_message(mp, attr->value, 0);
        if (!m) return NULL;
        
        /* Go through all the parts of the message: */
        for (part = msg->first_child; part; part = part->next) {
                /* Retrieve the name and type attributes of the part and allocate: */
                char *part_name = NULL;
                bs_data_type *part_type = NULL;
                bs_message_part *msg_part = NULL;
                for (attr = part->attr; attr; attr = attr->next) {
                        if (streq(attr->name, "name"))
                                part_name = apr_pstrdup(mp, attr->value);
                        if (streq(attr->name, "type")) {
                                part_type = lookup_data_type_by_name(def, attr->value);
                                if (!part_type) return NULL;
                        }
                }
                msg_part = new_bs_message_part(mp, part_name, part_type);
                add_part_to_message(m, msg_part, mp);
        }       
        return m;
}


static bs_message *lookup_message_by_element(const apr_xml_elem *elem,
        const bs_definition *def, apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        char *message_name = NULL;
        bs_uint32 i;
        
        /* Retrieve the message name from elem */
        for (attr = elem->attr; attr; attr = attr->next)
                if (streq(attr->name, "message"))
                        message_name = apr_pstrdup(mp, attr->value);
        if (!message_name) return NULL;
        
        /* Look for the message by its name in the given definition def: */
        for (i = 0; i < def->num_messages; i++) {
                bs_message *msg = def->messages[i];
                if (streq(msg->name, message_name)) return msg; 
        }
        return NULL;
}


static bs_operation *process_operation(const apr_xml_elem *op, bs_definition *def,
        apr_pool_t *mp)
{
        const apr_xml_elem *elem;
        const apr_xml_attr *attr;
        char *op_name = NULL;
        bs_message *input = NULL, *output = NULL, *fault = NULL;
        
        /* Process operation name attribute: */
        for (attr = op->attr; attr; attr = attr->next)
                if (streq(attr->name, "name"))
                        op_name = apr_pstrdup(mp, attr->value);
        if (!op_name) return NULL;
        
        /* Lookup the named input, output and/or fault messages: */
        for (elem = op->first_child; elem; elem = elem->next) {
                if (streq(elem->name, "input")) {
                        input = lookup_message_by_element(elem, def, mp);
                        if (!input) return NULL;
                }
                else if (streq(elem->name, "output")) {
                        output = lookup_message_by_element(elem, def, mp);
                        if (!output) return NULL;
                }
                else if (streq(elem->name, "fault")) {
                        fault = lookup_message_by_element(elem, def, mp);
                        if (!fault) return NULL;
                }
        }
        
        return new_bs_operation(mp, op_name, input, output, fault);     
}


static bs_port_type *process_porttype(const apr_xml_elem *pt, bs_definition *def,
                apr_pool_t *mp)
{
        const apr_xml_elem *operation;
        const apr_xml_attr *attr;
        bs_port_type *p = NULL;
        
        /* Process portType name attribute and allocate bs_port_type structure: */
        for (attr = pt->attr; attr; attr = attr->next)
                if (streq(attr->name, "name"))
                        p = new_bs_port_type(mp, attr->value, 0);
        if (!p) return NULL;
        
        /* Go through all the operations of the portType: */
        for (operation = pt->first_child; operation; operation = operation->next) {
                bs_operation *op = process_operation(operation, def, mp);
                if (!op) return NULL;
                add_operation_to_port_type(p, op, mp);
        }

        return p;       
}


static bs_port_type *lookup_porttype_by_name(const char *name, bs_definition *def)
{
        /* Look for the porttype by its name in the given definition def: */
        bs_uint16 i;
        for (i = 0; i < def->num_port_types; i++) {
                bs_port_type *pt = def->port_types[i];
                if (streq(pt->name, name)) return pt;   
        }
        return NULL;    
}


static bs_port *process_port(const apr_xml_elem *port, bs_definition *def,
                apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        char *port_name = NULL;
        bs_port_type *port_type = NULL;
        
        /* Find the name and type of the port and create a bs_port structure: */
        for (attr = port->attr; attr; attr = attr->next) {
                if (streq(attr->name, "name"))
                        port_name = apr_pstrdup(mp, attr->value);
                else if (streq(attr->name, "type")) {
                        port_type = lookup_porttype_by_name(attr->value, def);
                        if (!port_type) return NULL;
                }
        }
        return new_bs_port(mp, port_name, port_type);
}


static bs_service *process_service(const apr_xml_elem *svc, bs_definition *def,
                apr_pool_t *mp)
{
        const apr_xml_elem *port;
        const apr_xml_attr *attr;
        bs_service *s = NULL;
        
        /* Find the name of the service and create a bs_service structure: */
        for (attr = svc->attr; attr; attr = attr->next)
                if (streq(attr->name, "name"))
                        s = new_bs_service(mp, attr->value, 0);
        if (!s) return NULL;
        
        /* Process all port elements in this service: */
        for (port = svc->first_child; port; port = port->next) {
                bs_port *pt = process_port(port, def, mp);
                if (!pt) return NULL;
                add_port_to_service(s, pt, mp);
        }

        return s;       
}


static bs_status process_definition(const apr_xml_elem *root, bs_definition **def,
                apr_pool_t *mp)
{
        const apr_xml_elem *elem;
        const apr_xml_attr *attr;
        bs_definition *d = NULL;
        
        /* Process definition name attribute and allocate bs_definition structure: */
        for (attr = root->attr; attr; attr = attr->next)
                if (streq(attr->name, "name"))
                        d = new_bs_definition(mp, attr->value, 0, 0, 0, 0);
        if (!d) return BS_XML_PARSE_ERROR;
        
        /* Process the different child elements: */
        for (elem = root->first_child; elem; elem = elem->next) {
                if (streq(elem->name, "type")) {
                        bs_data_type *type = process_data_type(elem, mp);
                        if (!type) return BS_ERROR;
                        add_data_type_to_definition(d, type, mp);
                }
                else if (streq(elem->name, "message")) {
                        bs_message *msg = process_message(elem, d, mp);
                        if (!msg) return BS_ERROR;
                        add_message_to_definition(d, msg, mp);
                }
                else if (streq(elem->name, "portType")) {
                        bs_port_type *type = process_porttype(elem, d, mp);
                        if (!type) return BS_ERROR;
                        add_port_type_to_definition(d, type, mp);
                }
                else if (streq(elem->name, "service")) {
                        bs_service *svc = process_service(elem, d, mp);
                        if (!svc) return BS_ERROR;
                        add_service_to_definition(d, svc, mp);
                }
        }
        
        *def = d;
        return BS_OK;
}


/*******************************************************
 *                                                     *
 *  SERVICE REQUEST FROM XML HELPER FUNCTIONS          *
 *                                                     *
 *******************************************************/

static bs_status process_request_input_part(bs_part_instance **part,
                const apr_xml_elem *elem, apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        bs_part_instance *ret = NULL;
        char *name = NULL, *data = NULL;
        bs_data_type *type = NULL;
        
        /* Get the attributes of the part: */
        for (attr = elem->attr; attr; attr = attr->next) {
                if (streq(attr->name, "name"))
                        name = apr_pstrdup(mp, attr->value);
                else if (streq(attr->name, "type"))
                        type = new_bs_data_type(mp, attr->value);
        }
        if (!name || !type) return BS_XML_PARSE_ERROR;
        
        /* Copy (and decode if necessary) the data: */
        if (type->builtin) {
                if (elem->first_cdata.first == NULL) /* Be safe:  */
                        data = apr_pstrdup(mp, "");
                else
                        data = apr_pstrdup(mp, elem->first_cdata.first->text);
        }
        else {
                if (elem->first_cdata.first == NULL) /* Be safe:  */
                        data = apr_pstrdup(mp, "");
                else {
                        const char *encbuf = elem->first_cdata.first->text;
                        data = apr_pcalloc(mp, apr_base64_decode_len(encbuf));
                        apr_base64_decode(data, encbuf);
                }
        }
        ret = new_bs_part_instance(mp, name, type, data, strlen(data));
        if (!ret) return BS_ERROR;
        
        *part = ret;
        return BS_OK;
}


static bs_status process_request_input(const apr_xml_elem *msg,
                bs_service_request *request, apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        const apr_xml_elem *part;
        bs_message_instance *inst = NULL;
        
        /* Find the message name and allocate it: */
        for (attr = msg->attr; attr; attr = attr->next)
                if (streq(attr->name, "message"))
                        inst = new_bs_message_instance(mp, attr->value, 0);
        if (!inst) return BS_XML_PARSE_ERROR;
        
        /* Add the parts, one by one: */
        for (part = msg->first_child; part; part = part->next) {
                bs_part_instance *pinst;
                bs_status rv;
                
                /* Check if it's really a part and add to message instance: */
                if (!streq(part->name, "part"))
                        return BS_XML_PARSE_ERROR;
                rv = process_request_input_part(&pinst, part, mp);
                if (rv != BS_OK) return BS_XML_PARSE_ERROR;
                add_part_to_request_instance(pinst, inst, mp);
        }
        
        request->input = inst;
        return BS_OK;   
}


static bs_status process_request_use(const apr_xml_elem *elem,
                bs_service_request *request, apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        
        for (attr = elem->attr; attr; attr = attr->next) {
                if (streq(attr->name, "service"))
                        request->service = apr_pstrdup(mp, attr->value);
                else if (streq(attr->name, "port"))
                        request->port = apr_pstrdup(mp, attr->value);
                else if (streq(attr->name, "operation"))
                        request->operation = apr_pstrdup(mp, attr->value);
        }
        return BS_OK;   
}
 
 
static bs_status process_request(const apr_xml_elem *root,
                bs_service_request **request,
                apr_pool_t *mp)
{
        const apr_xml_elem *elem;
        const apr_xml_attr *attr;
        bs_service_request *r = NULL;
        
        /* Create a new service_request structure: */
        for (attr = root->attr; attr; attr = attr->next)
                if (streq(attr->name, "uuid")) {
                        bs_byte uuid[16];
                        apr_uuid_parse((apr_uuid_t *) &uuid, attr->value);
                        r = new_bs_service_request(mp, uuid, NULL, NULL, NULL, NULL);
                }
        if (!r) return BS_XML_PARSE_ERROR;
        
        /* Search for the <use> element which contains the requested service: */
        for (elem = root->first_child; elem; elem = elem->next) {
                if (streq(elem->name, "use")) {
                        bs_status rv = process_request_use(elem, r, mp);
                        if (rv != BS_OK) return BS_XML_PARSE_ERROR;
                }
                else if (streq(elem->name, "input")) {
                        bs_status rv = process_request_input(elem, r, mp);
                        if (rv != BS_OK) return BS_XML_PARSE_ERROR;
                }
        }
        
        *request = r;
        return BS_OK;
}

 
 /*******************************************************
 *                                                     *
 *  SERVICE RESPONSE FROM XML HELPER FUNCTIONS         *
 *                                                     *
 *******************************************************/
static bs_status process_response_output(const apr_xml_elem *msg,
                bs_service_response *response, apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        const apr_xml_elem *part;
        bs_message_instance *inst = NULL;
        
        /* Find the message name and allocate it: */
        for (attr = msg->attr; attr; attr = attr->next)
                if (streq(attr->name, "message"))
                        inst = new_bs_message_instance(mp, attr->value, 0);
        if (!inst) return BS_XML_PARSE_ERROR;
        
        /* Add the parts, one by one: */
        for (part = msg->first_child; part; part = part->next) {
                bs_part_instance *pinst;
                bs_status rv;
                
                /* Check if it's really a part and add to message instance: */
                if (!streq(part->name, "part"))
                        return BS_XML_PARSE_ERROR;
                rv = process_request_input_part(&pinst, part, mp);
                if (rv != BS_OK) return BS_XML_PARSE_ERROR;
                add_part_to_request_instance(pinst, inst, mp);
        }
        
        response->output = inst;
        return BS_OK;   
}


static bs_status process_response_fault(const apr_xml_elem *msg,
                bs_service_response *response, apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        const apr_xml_elem *part;
        bs_message_instance *inst = NULL;
        
        /* Find the message name and allocate it: */
        for (attr = msg->attr; attr; attr = attr->next)
                if (streq(attr->name, "message"))
                        inst = new_bs_message_instance(mp, attr->value, 0);
        if (!inst) return BS_XML_PARSE_ERROR;
        
        /* Add the parts, one by one: */
        for (part = msg->first_child; part; part = part->next) {
                bs_part_instance *pinst;
                bs_status rv;
                
                /* Check if it's really a part and add to message instance: */
                if (!streq(part->name, "part"))
                        return BS_XML_PARSE_ERROR;
                rv = process_request_input_part(&pinst, part, mp);
                if (rv != BS_OK) return BS_XML_PARSE_ERROR;
                add_part_to_request_instance(pinst, inst, mp);
        }
        
        response->output = inst;
        return BS_OK;   
}


static bs_status process_response_used(const apr_xml_elem *elem,
                bs_service_response *response, apr_pool_t *mp)
{
        const apr_xml_attr *attr;
        
        for (attr = elem->attr; attr; attr = attr->next) {
                if (streq(attr->name, "service"))
                        response->service = apr_pstrdup(mp, attr->value);
                else if (streq(attr->name, "port"))
                        response->port = apr_pstrdup(mp, attr->value);
                else if (streq(attr->name, "operation"))
                        response->operation = apr_pstrdup(mp, attr->value);
        }
        return BS_OK;   
}


static bs_status process_response(const apr_xml_elem *root,
                bs_service_response **response,
                apr_pool_t *mp)
{
        const apr_xml_elem *elem;
        const apr_xml_attr *attr;
        bs_service_response *r = NULL;
        
        /* Create a new service_request structure: */
        for (attr = root->attr; attr; attr = attr->next)
                if (streq(attr->name, "uuid")) {
                        bs_byte uuid[16];
                        apr_uuid_parse((apr_uuid_t *) &uuid, attr->value);
                        r = new_bs_service_response(mp, uuid, NULL, NULL, NULL, NULL, NULL);
                }
        if (!r) return BS_XML_PARSE_ERROR;
        
        /* Search for the <used> element which contains the requested service: */
        for (elem = root->first_child; elem; elem = elem->next) {
                if (streq(elem->name, "used")) {
                        bs_status rv = process_response_used(elem, r, mp);
                        if (rv != BS_OK) return BS_XML_PARSE_ERROR;
                }
                else if (streq(elem->name, "output")) {
                        bs_status rv = process_response_output(elem, r, mp);
                        if (rv != BS_OK) return BS_XML_PARSE_ERROR;
                }
                else if (streq(elem->name, "fault")) {
                        bs_status rv = process_response_fault(elem, r, mp);
                        if (rv != BS_OK) return BS_XML_PARSE_ERROR;
                }
        }
        
        *response = r;
        return BS_OK;   
}


static bs_status process_tree(const apr_xml_elem *root, void **object, unsigned *type, apr_pool_t *mp)
{
        /* This sometimes happens when expat is not correctly parsing: */
        if (!root) return BS_XML_PARSE_ERROR;
        
        if (streq(root->name, "definitions")) {
                *type = SERVICE_DEF_FROM_XML;
                return process_definition(root, (bs_definition **) object, mp);
        }
        else if (streq(root->name, "request")) {
                *type = SERVICE_REQUEST_FROM_XML;
                return process_request(root, (bs_service_request **) object, mp);
        }
        else if (streq(root->name, "response")) {
                *type = SERVICE_RESPONSE_FROM_XML;
                return process_response(root, (bs_service_response **) object, mp);
        }
        else return BS_XML_UNKNOWN_ROOT;        
}


bs_status xlate_from_xml(const char *buf, bs_uint64 limit, void **object,
                unsigned *type, apr_pool_t *mp)
{
        apr_xml_parser *parser = apr_xml_parser_create(mp);
        apr_xml_doc *doc;
    apr_status_t rv;
        
        /* Advance the pointer in the buffer until a '<' is encountered: */
        while (buf[0] != '<' && buf[0] != '\0' && limit > 0) {
                buf++;
                limit--;
        }

        /* Parse the given buffer with XML in one go: */
        rv = apr_xml_parser_feed(parser, buf, limit);
    if (rv != APR_SUCCESS) {
        char err[256];
        apr_xml_parser_geterror(parser, err, sizeof(err));
        fprintf(stderr, "XML parse error: %s\n", err);
        return BS_XML_NWF;
    }
    else apr_xml_parser_done(parser, &doc);
    
    /* Process the generated tree into a bs_definition/request/response struct: */
    return process_tree(doc->root, object, type, mp);    
}

---