xmlrpc.c

mms client

                (*msg)->parse_error = octstr_format("XML-RPC compiler: could not parse boolean value '%s'", 
                                                    octstr_get_cstr(value));
                return -1;
            }
            //xmlrpc_call_add_bool((*msg), (int) lval);
            xmlrpc_call_add_scalar((*msg), xr_bool, (void *) lval);
            debug("", 0, "XML-RPC: added boolean %d", (int) lval);
            break;

        case xr_string:
            //xmlrpc_call_add_string((*msg), value);
            xmlrpc_call_add_scalar((*msg), xr_string, (void *) value);
            debug("", 0, "XML-RPC: added string %s", octstr_get_cstr(value));
            break;

        case xr_date:
            //xmlrpc_call_add_date((*msg), value);
            xmlrpc_call_add_scalar((*msg), xr_date, (void *) value);
            debug("", 0, "XML-RPC: added date %s", octstr_get_cstr(value));
            break;

        case xr_base64:
            //xmlrpc_call_add_base64((*msg), value);
            xmlrpc_call_add_scalar((*msg), xr_base64, (void *) value);
            debug("", 0, "XML-RPC: added base64 %s", octstr_get_cstr(value));
            break;

        case xr_struct:
            if (parse_struct(doc, node->xmlChildrenNode, msg) == -1) {
                debug("", 0, "%s", octstr_get_cstr((*msg)->parse_error));
                //(*msg)->parse_status = XMLRPC_PARSING_FAILED;
                //(*msg)->parse_error = octstr_format("XML-RPC compiler: could not parse struct"); 
                return -1;
            }
            //debug("", 0, "XML-RPC: added struct %s", octstr_get_cstr(value));
            break;

        case xr_double:
        default:
            (*msg)->parse_status = XMLRPC_PARSING_FAILED;
            (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_value!");
            return -1;
            break;
    }

    octstr_destroy(value);
    return 0;
}


static int parse_value(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_value_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_value(doc, node->next, msg) == -1)
            return -1;

    return status;
}


static int parse_param_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_PARAM_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(param_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_PARAM_ELEMENTS) {
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
                                            "in XML source at level <param>", 
                                            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:
     *   value [0]
     */
    if (i == 0) {
        /* this has been a <param> tag */
        if (parse_value(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_param!");
        return -1;
    }
    return 0;
}


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

        case XML_ELEMENT_NODE:

            /* a <param> can only have one value element type */
            if ((*n) > 0) {
                (*msg)->parse_status = XMLRPC_PARSING_FAILED;
                (*msg)->parse_error = octstr_format("XML-RPC compiler: param may only have one value!");
                return -1;
            }

            status = parse_param_element(doc, node, msg);
            (*n)++;
            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_param(doc, node->next, msg, n) == -1)
            return -1;

    return status;
}


static int parse_params_element(xmlDocPtr doc, xmlNodePtr node, 
                                XMLRPCMethodCall **msg)
{
    Octstr *name;
    size_t i;
    int n = 0;

    /*
     * check if the element is allowed at this level
     * within <params> we only have one or more <param>
     */
    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }

    i = 0;
    while (i < NUMBER_OF_PARAMS_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(params_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_PARAMS_ELEMENTS) {
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
                                            "in XML source at level <params>", 
                                            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:
     *   param [0]
     */
    if (i == 0) {
        /* this has been a <param> tag */
        if (parse_param(doc, node->xmlChildrenNode, msg, &n) == -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_params!");
        return -1;
    }
    return 0;
}


static int parse_params(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_params_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 XML-RPC source.");
            return -1;
            break;
    }

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

    return status;
}


static int parse_methodcall_element(xmlDocPtr doc, xmlNodePtr node, 
                                    XMLRPCMethodCall **msg)
{
    Octstr *name;
    Octstr *value;
    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_METHODCALL_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(methodcall_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_METHODCALL_ELEMENTS) {
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' in XML source "
                                            "at level <methodCall>", 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:
     *   methodCall [0]
     *   params     [1]
     */
    if (i == 0) {
        /* this has been the <methodName> tag */
        value = octstr_create(xmlNodeListGetString(doc, node->xmlChildrenNode, 1));
                
        /* destroy current msg->method_name and redefine */
        octstr_destroy((*msg)->method_name);
        (*msg)->method_name = octstr_duplicate(value);
        octstr_destroy(value);

    } else {
        /* 
         * ok, this has to be an <params> tag, otherwise we would 
         * have returned previosly
         */
        if (parse_params(doc, node->xmlChildrenNode, msg) == -1)
            return -1;
    }
    return 0;
}


static int parse_methodcall(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_methodcall_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_methodcall(doc, node->next, msg) == -1)
            return -1;

    return status;
}

static int parse_document(xmlDocPtr document, XMLRPCMethodCall **msg)
{
    xmlNodePtr node;
    Octstr *name;

    node = xmlDocGetRootElement(document);

    /*
     * check if this is at least a valid root element
     */
    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }
    if (octstr_case_compare(name, octstr_imm("METHODCALL")) != 0) {
        (*msg)->parse_status = XMLRPC_PARSING_FAILED;
        (*msg)->parse_error = octstr_format("XML-RPC compiler: wrong root element <%s>, "
                                            "<methodCall> expected!", 
                                            octstr_get_cstr(name));
        octstr_destroy(name);
        return -1;
    }
    octstr_destroy(name);

    return parse_methodcall(document, node->xmlChildrenNode, msg);
}