xmlrpc.c

mms client

            break;
    }
    return scalar;
}

XMLRPCScalar *xmlrpc_scalar_create_double(int type, double val)
{
    XMLRPCScalar *scalar = gw_malloc(sizeof(XMLRPCScalar));

    scalar->s_type = type;
    scalar->s_int = 0;
    scalar->s_bool = 0;
    scalar->s_double = 0;
    scalar->s_str = NULL;
    scalar->s_date = NULL;
    scalar->s_base64 = NULL;
    
    switch (type) {
        case xr_double:
            scalar->s_double = val;
            break;
        default:
            panic(0,"XML-RPC: scalar type not supported!");
            break;
    }
    return scalar;
}

/* Destroy scalar */
void xmlrpc_scalar_destroy(XMLRPCScalar *scalar)
{
    if (scalar == NULL)
	return;

    octstr_destroy(scalar->s_str);
    octstr_destroy(scalar->s_date);
    octstr_destroy(scalar->s_base64);
    
    gw_free(scalar);
}

void xmlrpc_scalar_print(XMLRPCScalar *scalar, Octstr *os)
{
    switch (scalar->s_type) {
        case xr_int:
            octstr_format_append(os, "<int>%d</int>", scalar->s_int);
            break;
        case xr_bool:
            octstr_format_append(os, "<bool>%d</bool>", scalar->s_bool);
            break;
        case xr_string:
            octstr_format_append(os, "<string>%S</string>", scalar->s_str);
            break;
        case xr_double:
            octstr_format_append(os, "<double>%d</double>", scalar->s_double);
            break;
        case xr_date:
            octstr_format_append(os, "<date>%S</date>", scalar->s_date);
            break;
        case xr_base64:
            octstr_format_append(os, "<base64>%S</base64>", scalar->s_base64);
            break;
    }
}

/*-------------------------------------------------
 * Utilities to make things easier
 */


/* create scalar value from given arguments
 * XXX: Should this take different kind of arguments?
 */
XMLRPCValue *xmlrpc_create_scalar_value(int type, void *arg)
{
    XMLRPCValue *value = xmlrpc_value_create();
    value->v_type = xr_scalar;
    value->v_scalar = xmlrpc_scalar_create(type, arg);

    return value;
}

XMLRPCValue *xmlrpc_create_scalar_value_double(int type, double val)
{
    XMLRPCValue *value = xmlrpc_value_create();
    value->v_type = xr_scalar;
    value->v_scalar = xmlrpc_scalar_create_double(type, val);

    return value;
}

XMLRPCValue *xmlrpc_create_struct_value(int type, void *arg)
{
    XMLRPCValue *value = xmlrpc_value_create();
    value->v_type = xr_struct;
    value->v_struct = list_create();

    return value;
}

int xmlrpc_parse_status(XMLRPCMethodCall *call)
{
    if (call == NULL)
	   return -1;

    return call->parse_status;
}

Octstr *xmlrpc_parse_error(XMLRPCMethodCall *call) 
{
    if (call == NULL)
        return NULL;
    
    return call->parse_error;
}

Octstr *xmlrpc_get_method_name(XMLRPCMethodCall *call)
{
    if (call == NULL)
        return NULL;

    return call->method_name;
}

int xmlrpc_call_len(XMLRPCMethodCall *call)
{
    if (call == NULL)
        return 0;

    return list_len(call->params);
}

int xmlrpc_get_type(XMLRPCMethodCall *call, int pos)
{
    XMLRPCValue *var;

    if (call == NULL)
        return -1;

    var = list_get(call->params, pos);
    return var->v_type;
}


/*-------------------------------------------------
 * Internal parser functions
 */


static int parse_member_element(xmlDocPtr doc, xmlNodePtr node, 
                                XMLRPCMethodCall **msg)
{
    Octstr *name;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }

    i = 0;
    while (i < NUMBER_OF_MEMBER_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(member_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_MEMBER_ELEMENTS) {
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
                                            "in XML source at level <member>", 
                                            octstr_get_cstr(name));
        octstr_destroy(name);
        return -1;
    } 
    octstr_destroy(name);

    /* 
     * now check which type it is and process 
     *
     * valid tags at this level are:
     *   name [0]
     *   value [1]
     */
    if (i == 0) {
        /* this has been a <member> tag */
        //if (parse_name(doc, node->xmlChildrenNode, msg) == -1)
        //    return -1;
    } else {
        /* we should never be here */
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_member!");
        return -1;
    }
    return 0;
}


static int parse_member(xmlDocPtr doc, xmlNodePtr node, 
                        XMLRPCMethodCall **msg)
{
    int status = 0;
  
    /* call for the parser function of the node type. */
    switch (node->type) {

        case XML_ELEMENT_NODE:
            status = parse_member_element(doc, node, msg);
            break;

        case XML_TEXT_NODE:
        case XML_COMMENT_NODE:
        case XML_PI_NODE:
            /* Text nodes, comments and PIs are ignored. */
            break;
	   /*
	    * XML has also many other node types, these are not needed with 
	    * XML-RPC. Therefore they are assumed to be an error.
	    */
        default:
            (*msg)->parse_status = XMLRPC_PARSING_FAILED;
            (*msg)->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
            return -1;
            break;
    }

    if (node->next != NULL)
	   if (parse_member(doc, node->next, msg) == -1)
            return -1;

    return status;
}


static int parse_struct_element(xmlDocPtr doc, xmlNodePtr node, 
                                XMLRPCMethodCall **msg)
{
    Octstr *name;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }

    i = 0;
    while (i < NUMBER_OF_STRUCT_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(struct_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_STRUCT_ELEMENTS) {
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
                                            "in XML source at level <struct>", 
                                            octstr_get_cstr(name));
        octstr_destroy(name);
        return -1;
    } 
    octstr_destroy(name);

    /* 
     * now check which type it is and process 
     *
     * valid tags at this level are:
     *   member [0]
     */
    if (i == 0) {
        /* this has been a <member> tag */
        if (parse_member(doc, node->xmlChildrenNode, msg) == -1)
            return -1;
    } else {
        /* we should never be here */
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_struct!");
        return -1;
    }
    return 0;
}


static int parse_struct(xmlDocPtr doc, xmlNodePtr node, 
                        XMLRPCMethodCall **msg)
{
    int status = 0;
  
    /* call for the parser function of the node type. */
    switch (node->type) {

        case XML_ELEMENT_NODE:
            status = parse_struct_element(doc, node, msg);
            break;

        case XML_TEXT_NODE:
        case XML_COMMENT_NODE:
        case XML_PI_NODE:
            /* Text nodes, comments and PIs are ignored. */
            break;
	   /*
	    * XML has also many other node types, these are not needed with 
	    * XML-RPC. Therefore they are assumed to be an error.
	    */
        default:
            (*msg)->parse_status = XMLRPC_PARSING_FAILED;
            (*msg)->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
            return -1;
            break;
    }

    if (node->next != NULL)
	   if (parse_struct(doc, node->next, msg) == -1)
            return -1;

    return status;
}


static int parse_value_element(xmlDocPtr doc, xmlNodePtr node, 
                               XMLRPCMethodCall **msg)
{
    Octstr *name;
    Octstr *value;
    long lval = 0;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }

    i = 0;
    while (i < NUMBER_OF_VALUE_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(value_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_VALUE_ELEMENTS) {
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
                                            "in XML source at level <value>", 
                                            octstr_get_cstr(name));
        octstr_destroy(name);
        return -1;
    } 
    octstr_destroy(name);

    value = octstr_create(xmlNodeListGetString(doc, node->xmlChildrenNode, 1));
    if (value == NULL) {
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: no value for '%s'", 
                                            node->name);
        return -1;
    }

    /* 
     * now check which type it is and process 
     *
     * valid tags at this level are:
     *   i4, int
     *   boolean
     *   string
     *   double
     *   dateTime.iso8601
     *   base64
     *   struct
     *   array
     */
    switch (value_elements[i].s_type) {
        
        /*
         * scalar types
         */
        case xr_int:
            if (octstr_parse_long(&lval, value, 0, 10) < 0) {
                (*msg)->parse_status = XMLRPC_PARSING_FAILED;
                (*msg)->parse_error = octstr_format("XML-RPC compiler: could not parse int value '%s'", 
                                                    octstr_get_cstr(value));
                return -1;
            }
            //xmlrpc_call_add_int((*msg), lval);
            xmlrpc_call_add_scalar((*msg), xr_int, (void *) lval);
            debug("", 0, "XML-RPC: added int %ld", lval);
            break;
        
        case xr_bool:
            if (octstr_parse_long(&lval, value, 0, 10) < 0) {
                (*msg)->parse_status = XMLRPC_PARSING_FAILED;