开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
xmlrpc.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：32k
源码类别：

手机WAP编程

开发平台：

WINDOWS

xmlrpc.c：源码内容
  1. /*
  2.  * gwlib/xmlrpc.c: functions to handle XML-RPC structure - building and parsing
  3.  *
  4.  * XML-RPC is HTTP-based XML defination to handle remote procedure calls,
  5.  * and is defined at http://www.xml-rpc.org
  6.  *
  7.  * Kalle Marjola 2001 for project Kannel
  8.  * Stipe Tolj <tolj@wapme-systems.de>
  9.  */
  11. #include <libxml/xmlmemory.h>
  12. #include <libxml/tree.h>
  13. #include <libxml/debugXML.h>
  14. #include <libxml/encoding.h>
  16. #include "gwlib/gwlib.h"
  17. #include "gwlib/xmlrpc.h"
  19. struct xmlrpc_methodcall {
  20.     Octstr *method_name;
  21.     List *params;         /* List of XMLRPCValues */
  22.     int parse_status;     /* enum here */
  23.     Octstr *parse_error;  /* error string in case of parsing error */
  24. };
  26. struct xmlrpc_methodresponse {
  27.     XMLRPCValue *param; /* either this... */
  28.     XMLRPCValue *fault;  /* ..or this */
  29. };
  31. struct xmlrpc_value {
  32.     int v_type; /* enum here */
  33.     XMLRPCScalar *v_scalar;
  34.     List *v_array;     /* List of XMLRPCValues */
  35.     List *v_struct;    /* List of XMLRPMembers */
  36. };
  38. struct xmlrpc_member { /* member of struct */
  39.     Octstr *name;
  40.     XMLRPCValue *value;
  41. };
  43. struct xmlrpc_scalar {
  44.     int s_type; /* enum here */
  45.     Octstr *s_str;
  46.     long s_int;
  47.     int s_bool;
  48.     double s_double;
  49.     Octstr *s_date;
  50.     Octstr *s_base64;
  51. };
  53. struct xmlrpc_table_t {
  54.     char *name;
  55. };
  57. struct xmlrpc_2table_t {
  58.     char *name;
  59.     int s_type; /* enum here */
  60. };
  62. static xmlrpc_table_t methodcall_elements[] = {
  63.     { "METHODNAME" },
  64.     { "PARAMS" }
  65. };
  67. static xmlrpc_table_t params_elements[] = {
  68.     { "PARAM" }
  69. };
  71. static xmlrpc_table_t param_elements[] = {
  72.     { "VALUE" }
  73. };
  75. static xmlrpc_2table_t value_elements[] = {
  76.     { "I4", xr_int },
  77.     { "INT", xr_int },
  78.     { "BOOLEAN", xr_bool },
  79.     { "STRING", xr_string },
  80.     { "DOUBLE", xr_double },
  81.     { "DATETIME.ISO8601", xr_date },
  82.     { "BASE64", xr_base64 },
  83.     { "STRUCT", xr_struct },
  84.     { "ARRAY", xr_array }
  85. };
  87. static xmlrpc_table_t struct_elements[] = {
  88.     { "MEMBER" }
  89. };
  91. static xmlrpc_table_t member_elements[] = {
  92.     { "NAME" },
  93.     { "VALUE" }
  94. };
  97. #define NUMBER_OF_METHODCALL_ELEMENTS 
  98.     sizeof(methodcall_elements)/sizeof(methodcall_elements[0])
  99. #define NUMBER_OF_PARAMS_ELEMENTS 
  100.     sizeof(params_elements)/sizeof(params_elements[0])
  101. #define NUMBER_OF_PARAM_ELEMENTS 
  102.     sizeof(param_elements)/sizeof(param_elements[0])
  103. #define NUMBER_OF_VALUE_ELEMENTS 
  104.     sizeof(value_elements)/sizeof(value_elements[0])
  105. #define NUMBER_OF_STRUCT_ELEMENTS 
  106.     sizeof(struct_elements)/sizeof(struct_elements[0])
  107. #define NUMBER_OF_MEMBER_ELEMENTS 
  108.     sizeof(member_elements)/sizeof(member_elements[0])
  111. static int parse_document(xmlDocPtr document, XMLRPCMethodCall **msg);
  112. static int parse_methodcall(xmlDocPtr doc, xmlNodePtr node, 
  113.                             XMLRPCMethodCall **msg);
  114. static int parse_methodcall_element(xmlDocPtr doc, xmlNodePtr node, 
  115.                                     XMLRPCMethodCall **msg);
  116. static int parse_params(xmlDocPtr doc, xmlNodePtr node, 
  117.                         XMLRPCMethodCall **msg);
  118. static int parse_params_element(xmlDocPtr doc, xmlNodePtr node, 
  119.                                 XMLRPCMethodCall **msg);
  120. static int parse_param(xmlDocPtr doc, xmlNodePtr node, 
  121.                        XMLRPCMethodCall **msg, int *n);
  122. static int parse_param_element(xmlDocPtr doc, xmlNodePtr node, 
  123.                                XMLRPCMethodCall **msg);
  124. static int parse_value(xmlDocPtr doc, xmlNodePtr node, 
  125.                        XMLRPCMethodCall **msg);
  126. static int parse_value_element(xmlDocPtr doc, xmlNodePtr node, 
  127.                                XMLRPCMethodCall **msg);
  130. /*-------------------------------------
  131.  * MethodCall
  132.  */
  134. XMLRPCMethodCall *xmlrpc_call_create(Octstr *name)
  135. {
  136.     XMLRPCMethodCall *nmsg = gw_malloc(sizeof(XMLRPCMethodCall));
  138.     nmsg->method_name = octstr_duplicate(name);
  139.     nmsg->params = list_create();
  140.     nmsg->parse_status = XMLRPC_COMPILE_OK;
  141.     nmsg->parse_error = NULL;
  142.     
  143.     return nmsg;
  144. }
  146. XMLRPCMethodCall *xmlrpc_call_parse(Octstr *post_body)
  147. {
  148.     XMLRPCMethodCall *msg = gw_malloc(sizeof(XMLRPCMethodCall));
  149.     xmlDocPtr pDoc;
  150.     size_t size;
  151.     char *body;
  152.     int ret;
  154.     msg->method_name = octstr_create("");
  155.     msg->params = list_create();
  156.     msg->parse_status = XMLRPC_COMPILE_OK;
  157.     msg->parse_error = NULL;
  159.     octstr_strip_blanks(post_body);
  160.     octstr_shrink_blanks(post_body);
  161.     size = octstr_len(post_body);
  162.     body = octstr_get_cstr(post_body);
  164.     /* parse XML document to a XML tree */
  165.     pDoc = xmlParseMemory(body, size);
  167.     ret = parse_document(pDoc, &msg);
  168.     xmlFreeDoc(pDoc);
  169.     return msg;
  170. }
  172. void xmlrpc_call_destroy(XMLRPCMethodCall *call)
  173. {
  174.     if (call == NULL)
  175. return;
  177.     octstr_destroy(call->method_name);
  178.     list_destroy(call->params, xmlrpc_value_destroy_item);
  180.     if (call->parse_error != NULL)
  181.         octstr_destroy(call->parse_error);
  183.     gw_free(call);
  184. }
  186. int xmlrpc_call_add_scalar(XMLRPCMethodCall *method, int type, void *arg)
  187. {
  188.     XMLRPCValue *nval;
  189.     if (method == NULL)
  190.         return -1;
  191.     nval = xmlrpc_create_scalar_value(type, arg);
  192.     list_produce(method->params, nval);
  193.     return 0;
  194. }
  196. int xmlrpc_call_add_value(XMLRPCMethodCall *method, XMLRPCValue *value)
  197. {
  198.     if (method == NULL || value == NULL)
  199. return -1;
  201.     list_produce(method->params, value);
  202.     return 0;
  203. }
  205. Octstr *xmlrpc_call_octstr(XMLRPCMethodCall *call)
  206. {
  207.     Octstr *body;
  208.     XMLRPCValue *val;
  209.     long i;
  210.     
  211.     body = octstr_format("<?xml version="1.0"?>n<methodCall>n"
  212.              "  <methodName>%S</methodName>n"
  213.              "  <params>", call->method_name);
  215.     list_lock(call->params);
  216.     for (i = 0; i < list_len(call->params); i++) {
  217.         val = list_get(call->params, i);
  218.         octstr_format_append(body, "n    <param>n"
  219.                              "n      ");
  220.         xmlrpc_value_print(val, body);
  221.         octstr_format_append(body, "n    </param>n");
  222.         
  223.     }
  224.     list_unlock(call->params);
  225.     
  226.     octstr_format_append(body, "  </params>n"
  227.              "</methodCall>n");
  229.     return body;
  230. }
  232. int xmlrpc_call_send(XMLRPCMethodCall *call, HTTPCaller *http_ref,
  233.      Octstr *url, List *headers, void *ref)
  234. {
  235.     Octstr *body;
  236.     if (http_ref == NULL || call == NULL)
  237. return -1;
  238.     
  239.     if (headers == NULL)
  240. headers = list_create();
  241.     
  242.     http_header_add(headers, "Content-Type", "text/xml");
  244.     /* 
  245.      * XML-RPC specs say we at least need Host and User-Agent 
  246.      * HTTP headers to be defined.
  247.      * These are set anyway within gwlib/http.c:build_request()
  248.      */
  249.     body = xmlrpc_call_octstr(call);
  251.     http_start_request(http_ref, HTTP_METHOD_GET, 
  252.                        url, headers, body, 0, ref, NULL);
  253.     
  254.     octstr_destroy(body);
  255.     http_destroy_headers(headers);
  256.     return 0;
  257. }
  259. /*-------------------------------------
  260.  * MethodResponse
  261.  */
  264. XMLRPCMethodResponse *xmlrpc_response_create(XMLRPCValue *param)
  265. {
  266.     XMLRPCMethodResponse *nmsg = gw_malloc(sizeof(XMLRPCMethodResponse));
  268.     nmsg->param = param;
  269.     nmsg->fault = NULL;
  270.     
  271.     return nmsg;
  272. }
  274. void xmlrpc_response_destroy(XMLRPCMethodResponse *response)
  275. {
  276.     if (response == NULL)
  277. return;
  279.     xmlrpc_value_destroy(response->param);
  280.     xmlrpc_value_destroy(response->fault);
  282.     gw_free(response);
  283. }
  286. /* Create new value. Set type of it to undefined, so it must be
  287.  * set laterwards to correct one
  288.  */
  289. XMLRPCValue *xmlrpc_value_create(void)
  290. {
  291.     XMLRPCValue *val = gw_malloc(sizeof(XMLRPCValue));
  293.     val->v_type = xr_undefined;
  294.     val->v_scalar = NULL;
  295.     val->v_array = NULL;
  296.     val->v_struct = NULL;
  297.     return val;
  298. }
  300. /* Destroy value with its information, recursively if need to */
  301. void xmlrpc_value_destroy(XMLRPCValue *val)
  302. {
  303.     if (val == NULL)
  304. return;
  306.     switch(val->v_type) {
  307.     case xr_scalar:
  308. xmlrpc_scalar_destroy(val->v_scalar);
  309. break;
  310.     case xr_array:
  311. list_destroy(val->v_array, xmlrpc_value_destroy_item);
  312. break;
  313.     case xr_struct:
  314. list_destroy(val->v_struct, xmlrpc_member_destroy_item);
  315. break;
  316.     }
  317.     gw_free(val);
  318. }
  320. /* wrapper to destroy to be used with list */
  321. void xmlrpc_value_destroy_item(void *val)
  322. {
  323.     xmlrpc_value_destroy(val);
  324. }
  326. void xmlrpc_value_print(XMLRPCValue *val, Octstr *os)
  327. {
  328.     if (val->v_type != xr_scalar)
  329. return;
  331.     octstr_format_append(os, "<value>");
  332.     xmlrpc_scalar_print(val->v_scalar, os);
  333.     octstr_format_append(os, "</value>");
  334. }
  338. /* Create new member with undefined value */
  339. XMLRPCMember *xmlrpc_member_create(Octstr *name)
  340. {
  341.     XMLRPCMember *member = gw_malloc(sizeof(XMLRPCMember));
  343.     gw_assert(name);
  344.     member->name = octstr_duplicate(name);
  345.     member->value = xmlrpc_value_create();
  347.     return member;
  348. }
  350. /* Destroy member and its contents */
  351. void xmlrpc_member_destroy(XMLRPCMember *member)
  352. {
  353.     if (member == NULL)
  354. return;
  356.     xmlrpc_value_destroy(member->value);
  357.     octstr_destroy(member->name);
  359.     gw_free(member);
  360. }
  362. void xmlrpc_member_destroy_item(void *member)
  363. {
  364.     xmlrpc_member_destroy(member);
  365. }
  368. /* Create new scalar of given type with given argument */
  369. XMLRPCScalar *xmlrpc_scalar_create(int type, void *arg)
  370. {
  371.     XMLRPCScalar *scalar = gw_malloc(sizeof(XMLRPCScalar));
  373.     scalar->s_type = type;
  374.     scalar->s_int = 0;
  375.     scalar->s_bool = 0;
  376.     scalar->s_double = 0;
  377.     scalar->s_str = NULL;
  378.     scalar->s_date = NULL;
  379.     scalar->s_base64 = NULL;
  380.     
  381.     switch (type) {
  382.         case xr_int:
  383.             scalar->s_int = (long)arg;
  384.             break;
  385.         case xr_bool:
  386.             scalar->s_bool = (int)arg;
  387.             break;
  388.         case xr_string:
  389.             scalar->s_str = octstr_duplicate((Octstr *)arg);
  390.             break;
  391.         case xr_date:
  392.             scalar->s_date = octstr_duplicate((Octstr *)arg);
  393.             break;
  394.         case xr_base64:
  395.             scalar->s_base64 = octstr_duplicate((Octstr *)arg);
  396.             break;
  397.         default:
  398.             panic(0,"XML-RPC: scalar type not supported!");
  399.             break;
  400.     }
  401.     return scalar;
  402. }
  404. XMLRPCScalar *xmlrpc_scalar_create_double(int type, double val)
  405. {
  406.     XMLRPCScalar *scalar = gw_malloc(sizeof(XMLRPCScalar));
  408.     scalar->s_type = type;
  409.     scalar->s_int = 0;
  410.     scalar->s_bool = 0;
  411.     scalar->s_double = 0;
  412.     scalar->s_str = NULL;
  413.     scalar->s_date = NULL;
  414.     scalar->s_base64 = NULL;
  415.     
  416.     switch (type) {
  417.         case xr_double:
  418.             scalar->s_double = val;
  419.             break;
  420.         default:
  421.             panic(0,"XML-RPC: scalar type not supported!");
  422.             break;
  423.     }
  424.     return scalar;
  425. }
  427. /* Destroy scalar */
  428. void xmlrpc_scalar_destroy(XMLRPCScalar *scalar)
  429. {
  430.     if (scalar == NULL)
  431. return;
  433.     octstr_destroy(scalar->s_str);
  434.     octstr_destroy(scalar->s_date);
  435.     octstr_destroy(scalar->s_base64);
  436.     
  437.     gw_free(scalar);
  438. }
  440. void xmlrpc_scalar_print(XMLRPCScalar *scalar, Octstr *os)
  441. {
  442.     switch (scalar->s_type) {
  443.         case xr_int:
  444.             octstr_format_append(os, "<int>%d</int>", scalar->s_int);
  445.             break;
  446.         case xr_bool:
  447.             octstr_format_append(os, "<bool>%d</bool>", scalar->s_bool);
  448.             break;
  449.         case xr_string:
  450.             octstr_format_append(os, "<string>%S</string>", scalar->s_str);
  451.             break;
  452.         case xr_double:
  453.             octstr_format_append(os, "<double>%d</double>", scalar->s_double);
  454.             break;
  455.         case xr_date:
  456.             octstr_format_append(os, "<date>%S</date>", scalar->s_date);
  457.             break;
  458.         case xr_base64:
  459.             octstr_format_append(os, "<base64>%S</base64>", scalar->s_base64);
  460.             break;
  461.     }
  462. }
  464. /*-------------------------------------------------
  465.  * Utilities to make things easier
  466.  */
  469. /* create scalar value from given arguments
  470.  * XXX: Should this take different kind of arguments?
  471.  */
  472. XMLRPCValue *xmlrpc_create_scalar_value(int type, void *arg)
  473. {
  474.     XMLRPCValue *value = xmlrpc_value_create();
  475.     value->v_type = xr_scalar;
  476.     value->v_scalar = xmlrpc_scalar_create(type, arg);
  478.     return value;
  479. }
  481. XMLRPCValue *xmlrpc_create_scalar_value_double(int type, double val)
  482. {
  483.     XMLRPCValue *value = xmlrpc_value_create();
  484.     value->v_type = xr_scalar;
  485.     value->v_scalar = xmlrpc_scalar_create_double(type, val);
  487.     return value;
  488. }
  490. XMLRPCValue *xmlrpc_create_struct_value(int type, void *arg)
  491. {
  492.     XMLRPCValue *value = xmlrpc_value_create();
  493.     value->v_type = xr_struct;
  494.     value->v_struct = list_create();
  496.     return value;
  497. }
  499. int xmlrpc_parse_status(XMLRPCMethodCall *call)
  500. {
  501.     if (call == NULL)
  502.    return -1;
  504.     return call->parse_status;
  505. }
  507. Octstr *xmlrpc_parse_error(XMLRPCMethodCall *call) 
  508. {
  509.     if (call == NULL)
  510.         return NULL;
  511.     
  512.     return call->parse_error;
  513. }
  515. Octstr *xmlrpc_get_method_name(XMLRPCMethodCall *call)
  516. {
  517.     if (call == NULL)
  518.         return NULL;
  520.     return call->method_name;
  521. }
  523. int xmlrpc_call_len(XMLRPCMethodCall *call)
  524. {
  525.     if (call == NULL)
  526.         return 0;
  528.     return list_len(call->params);
  529. }
  531. int xmlrpc_get_type(XMLRPCMethodCall *call, int pos)
  532. {
  533.     XMLRPCValue *var;
  535.     if (call == NULL)
  536.         return -1;
  538.     var = list_get(call->params, pos);
  539.     return var->v_type;
  540. }
  543. /*-------------------------------------------------
  544.  * Internal parser functions
  545.  */
  548. static int parse_member_element(xmlDocPtr doc, xmlNodePtr node, 
  549.                                 XMLRPCMethodCall **msg)
  550. {
  551.     Octstr *name;
  552.     size_t i;
  554.     /*
  555.      * check if the element is allowed at this level 
  556.      */
  557.     name = octstr_create(node->name);
  558.     if (octstr_len(name) == 0) {
  559.         octstr_destroy(name);
  560.         return -1;
  561.     }
  563.     i = 0;
  564.     while (i < NUMBER_OF_MEMBER_ELEMENTS) {
  565.         if (octstr_case_compare(name, octstr_imm(member_elements[i].name)) == 0)
  566.             break;
  567.         ++i;
  568.     }
  569.     if (i == NUMBER_OF_MEMBER_ELEMENTS) {
  570.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  571.         (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
  572.                                             "in XML source at level <member>", 
  573.                                             octstr_get_cstr(name));
  574.         octstr_destroy(name);
  575.         return -1;
  576.     } 
  577.     octstr_destroy(name);
  579.     /* 
  580.      * now check which type it is and process 
  581.      *
  582.      * valid tags at this level are:
  583.      *   name [0]
  584.      *   value [1]
  585.      */
  586.     if (i == 0) {
  587.         /* this has been a <member> tag */
  588.         //if (parse_name(doc, node->xmlChildrenNode, msg) == -1)
  589.         //    return -1;
  590.     } else {
  591.         /* we should never be here */
  592.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  593.         (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_member!");
  594.         return -1;
  595.     }
  596.     return 0;
  597. }
  600. static int parse_member(xmlDocPtr doc, xmlNodePtr node, 
  601.                         XMLRPCMethodCall **msg)
  602. {
  603.     int status = 0;
  604.   
  605.     /* call for the parser function of the node type. */
  606.     switch (node->type) {
  608.         case XML_ELEMENT_NODE:
  609.             status = parse_member_element(doc, node, msg);
  610.             break;
  612.         case XML_TEXT_NODE:
  613.         case XML_COMMENT_NODE:
  614.         case XML_PI_NODE:
  615.             /* Text nodes, comments and PIs are ignored. */
  616.             break;
  617.    /*
  618.     * XML has also many other node types, these are not needed with 
  619.     * XML-RPC. Therefore they are assumed to be an error.
  620.     */
  621.         default:
  622.             (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  623.             (*msg)->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
  624.             return -1;
  625.             break;
  626.     }
  628.     if (node->next != NULL)
  629.    if (parse_member(doc, node->next, msg) == -1)
  630.             return -1;
  632.     return status;
  633. }
  636. static int parse_struct_element(xmlDocPtr doc, xmlNodePtr node, 
  637.                                 XMLRPCMethodCall **msg)
  638. {
  639.     Octstr *name;
  640.     size_t i;
  642.     /*
  643.      * check if the element is allowed at this level 
  644.      */
  645.     name = octstr_create(node->name);
  646.     if (octstr_len(name) == 0) {
  647.         octstr_destroy(name);
  648.         return -1;
  649.     }
  651.     i = 0;
  652.     while (i < NUMBER_OF_STRUCT_ELEMENTS) {
  653.         if (octstr_case_compare(name, octstr_imm(struct_elements[i].name)) == 0)
  654.             break;
  655.         ++i;
  656.     }
  657.     if (i == NUMBER_OF_STRUCT_ELEMENTS) {
  658.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  659.         (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
  660.                                             "in XML source at level <struct>", 
  661.                                             octstr_get_cstr(name));
  662.         octstr_destroy(name);
  663.         return -1;
  664.     } 
  665.     octstr_destroy(name);
  667.     /* 
  668.      * now check which type it is and process 
  669.      *
  670.      * valid tags at this level are:
  671.      *   member [0]
  672.      */
  673.     if (i == 0) {
  674.         /* this has been a <member> tag */
  675.         if (parse_member(doc, node->xmlChildrenNode, msg) == -1)
  676.             return -1;
  677.     } else {
  678.         /* we should never be here */
  679.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  680.         (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_struct!");
  681.         return -1;
  682.     }
  683.     return 0;
  684. }
  687. static int parse_struct(xmlDocPtr doc, xmlNodePtr node, 
  688.                         XMLRPCMethodCall **msg)
  689. {
  690.     int status = 0;
  691.   
  692.     /* call for the parser function of the node type. */
  693.     switch (node->type) {
  695.         case XML_ELEMENT_NODE:
  696.             status = parse_struct_element(doc, node, msg);
  697.             break;
  699.         case XML_TEXT_NODE:
  700.         case XML_COMMENT_NODE:
  701.         case XML_PI_NODE:
  702.             /* Text nodes, comments and PIs are ignored. */
  703.             break;
  704.    /*
  705.     * XML has also many other node types, these are not needed with 
  706.     * XML-RPC. Therefore they are assumed to be an error.
  707.     */
  708.         default:
  709.             (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  710.             (*msg)->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
  711.             return -1;
  712.             break;
  713.     }
  715.     if (node->next != NULL)
  716.    if (parse_struct(doc, node->next, msg) == -1)
  717.             return -1;
  719.     return status;
  720. }
  723. static int parse_value_element(xmlDocPtr doc, xmlNodePtr node, 
  724.                                XMLRPCMethodCall **msg)
  725. {
  726.     Octstr *name;
  727.     Octstr *value;
  728.     long lval = 0;
  729.     size_t i;
  731.     /*
  732.      * check if the element is allowed at this level 
  733.      */
  734.     name = octstr_create(node->name);
  735.     if (octstr_len(name) == 0) {
  736.         octstr_destroy(name);
  737.         return -1;
  738.     }
  740.     i = 0;
  741.     while (i < NUMBER_OF_VALUE_ELEMENTS) {
  742.         if (octstr_case_compare(name, octstr_imm(value_elements[i].name)) == 0)
  743.             break;
  744.         ++i;
  745.     }
  746.     if (i == NUMBER_OF_VALUE_ELEMENTS) {
  747.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  748.         (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
  749.                                             "in XML source at level <value>", 
  750.                                             octstr_get_cstr(name));
  751.         octstr_destroy(name);
  752.         return -1;
  753.     } 
  754.     octstr_destroy(name);
  756.     value = octstr_create(xmlNodeListGetString(doc, node->xmlChildrenNode, 1));
  757.     if (value == NULL) {
  758.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  759.         (*msg)->parse_error = octstr_format("XML-RPC compiler: no value for '%s'", 
  760.                                             node->name);
  761.         return -1;
  762.     }
  764.     /* 
  765.      * now check which type it is and process 
  766.      *
  767.      * valid tags at this level are:
  768.      *   i4, int
  769.      *   boolean
  770.      *   string
  771.      *   double
  772.      *   dateTime.iso8601
  773.      *   base64
  774.      *   struct
  775.      *   array
  776.      */
  777.     switch (value_elements[i].s_type) {
  778.         
  779.         /*
  780.          * scalar types
  781.          */
  782.         case xr_int:
  783.             if (octstr_parse_long(&lval, value, 0, 10) < 0) {
  784.                 (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  785.                 (*msg)->parse_error = octstr_format("XML-RPC compiler: could not parse int value '%s'", 
  786.                                                     octstr_get_cstr(value));
  787.                 return -1;
  788.             }
  789.             //xmlrpc_call_add_int((*msg), lval);
  790.             xmlrpc_call_add_scalar((*msg), xr_int, (void *) lval);
  791.             debug("", 0, "XML-RPC: added int %ld", lval);
  792.             break;
  793.         
  794.         case xr_bool:
  795.             if (octstr_parse_long(&lval, value, 0, 10) < 0) {
  796.                 (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  797.                 (*msg)->parse_error = octstr_format("XML-RPC compiler: could not parse boolean value '%s'", 
  798.                                                     octstr_get_cstr(value));
  799.                 return -1;
  800.             }
  801.             //xmlrpc_call_add_bool((*msg), (int) lval);
  802.             xmlrpc_call_add_scalar((*msg), xr_bool, (void *) lval);
  803.             debug("", 0, "XML-RPC: added boolean %d", (int) lval);
  804.             break;
  806.         case xr_string:
  807.             //xmlrpc_call_add_string((*msg), value);
  808.             xmlrpc_call_add_scalar((*msg), xr_string, (void *) value);
  809.             debug("", 0, "XML-RPC: added string %s", octstr_get_cstr(value));
  810.             break;
  812.         case xr_date:
  813.             //xmlrpc_call_add_date((*msg), value);
  814.             xmlrpc_call_add_scalar((*msg), xr_date, (void *) value);
  815.             debug("", 0, "XML-RPC: added date %s", octstr_get_cstr(value));
  816.             break;
  818.         case xr_base64:
  819.             //xmlrpc_call_add_base64((*msg), value);
  820.             xmlrpc_call_add_scalar((*msg), xr_base64, (void *) value);
  821.             debug("", 0, "XML-RPC: added base64 %s", octstr_get_cstr(value));
  822.             break;
  824.         case xr_struct:
  825.             if (parse_struct(doc, node->xmlChildrenNode, msg) == -1) {
  826.                 debug("", 0, "%s", octstr_get_cstr((*msg)->parse_error));
  827.                 //(*msg)->parse_status = XMLRPC_PARSING_FAILED;
  828.                 //(*msg)->parse_error = octstr_format("XML-RPC compiler: could not parse struct"); 
  829.                 return -1;
  830.             }
  831.             //debug("", 0, "XML-RPC: added struct %s", octstr_get_cstr(value));
  832.             break;
  834.         case xr_double:
  835.         default:
  836.             (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  837.             (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_value!");
  838.             return -1;
  839.             break;
  840.     }
  842.     octstr_destroy(value);
  843.     return 0;
  844. }
  847. static int parse_value(xmlDocPtr doc, xmlNodePtr node, 
  848.                        XMLRPCMethodCall **msg)
  849. {
  850.     int status = 0;
  851.   
  852.     /* call for the parser function of the node type. */
  853.     switch (node->type) {
  855.         case XML_ELEMENT_NODE:
  856.             status = parse_value_element(doc, node, msg);
  857.             break;
  859.         case XML_TEXT_NODE:
  860.         case XML_COMMENT_NODE:
  861.         case XML_PI_NODE:
  862.             /* Text nodes, comments and PIs are ignored. */
  863.             break;
  864.    /*
  865.     * XML has also many other node types, these are not needed with 
  866.     * XML-RPC. Therefore they are assumed to be an error.
  867.     */
  868.         default:
  869.             (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  870.             (*msg)->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
  871.             return -1;
  872.             break;
  873.     }
  875.     if (node->next != NULL)
  876.    if (parse_value(doc, node->next, msg) == -1)
  877.             return -1;
  879.     return status;
  880. }
  883. static int parse_param_element(xmlDocPtr doc, xmlNodePtr node, 
  884.                                XMLRPCMethodCall **msg)
  885. {
  886.     Octstr *name;
  887.     size_t i;
  889.     /*
  890.      * check if the element is allowed at this level 
  891.      */
  892.     name = octstr_create(node->name);
  893.     if (octstr_len(name) == 0) {
  894.         octstr_destroy(name);
  895.         return -1;
  896.     }
  898.     i = 0;
  899.     while (i < NUMBER_OF_PARAM_ELEMENTS) {
  900.         if (octstr_case_compare(name, octstr_imm(param_elements[i].name)) == 0)
  901.             break;
  902.         ++i;
  903.     }
  904.     if (i == NUMBER_OF_PARAM_ELEMENTS) {
  905.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  906.         (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
  907.                                             "in XML source at level <param>", 
  908.                                             octstr_get_cstr(name));
  909.         octstr_destroy(name);
  910.         return -1;
  911.     } 
  912.     octstr_destroy(name);
  914.     /* 
  915.      * now check which type it is and process 
  916.      *
  917.      * valid tags at this level are:
  918.      *   value [0]
  919.      */
  920.     if (i == 0) {
  921.         /* this has been a <param> tag */
  922.         if (parse_value(doc, node->xmlChildrenNode, msg) == -1)
  923.             return -1;
  924.     } else {
  925.         /* we should never be here */
  926.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  927.         (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_param!");
  928.         return -1;
  929.     }
  930.     return 0;
  931. }
  934. static int parse_param(xmlDocPtr doc, xmlNodePtr node, 
  935.                        XMLRPCMethodCall **msg, int *n)
  936. {
  937.     int status = 0;
  938.   
  939.     /* call for the parser function of the node type. */
  940.     switch (node->type) {
  942.         case XML_ELEMENT_NODE:
  944.             /* a <param> can only have one value element type */
  945.             if ((*n) > 0) {
  946.                 (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  947.                 (*msg)->parse_error = octstr_format("XML-RPC compiler: param may only have one value!");
  948.                 return -1;
  949.             }
  951.             status = parse_param_element(doc, node, msg);
  952.             (*n)++;
  953.             break;
  955.         case XML_TEXT_NODE:
  956.         case XML_COMMENT_NODE:
  957.         case XML_PI_NODE:
  958.             /* Text nodes, comments and PIs are ignored. */
  959.             break;
  960.    /*
  961.     * XML has also many other node types, these are not needed with 
  962.     * XML-RPC. Therefore they are assumed to be an error.
  963.     */
  964.         default:
  965.             (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  966.             (*msg)->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
  967.             return -1;
  968.             break;
  969.     }
  970.    
  971.     if (node->next != NULL)
  972.    if (parse_param(doc, node->next, msg, n) == -1)
  973.             return -1;
  975.     return status;
  976. }
  979. static int parse_params_element(xmlDocPtr doc, xmlNodePtr node, 
  980.                                 XMLRPCMethodCall **msg)
  981. {
  982.     Octstr *name;
  983.     size_t i;
  984.     int n = 0;
  986.     /*
  987.      * check if the element is allowed at this level
  988.      * within <params> we only have one or more <param>
  989.      */
  990.     name = octstr_create(node->name);
  991.     if (octstr_len(name) == 0) {
  992.         octstr_destroy(name);
  993.         return -1;
  994.     }
  996.     i = 0;
  997.     while (i < NUMBER_OF_PARAMS_ELEMENTS) {
  998.         if (octstr_case_compare(name, octstr_imm(params_elements[i].name)) == 0)
  999.             break;
  1000.         ++i;
  1001.     }
  1002.     if (i == NUMBER_OF_PARAMS_ELEMENTS) {
  1003.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  1004.         (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
  1005.                                             "in XML source at level <params>", 
  1006.                                             octstr_get_cstr(name));
  1007.         octstr_destroy(name);
  1008.         return -1;
  1009.     } 
  1010.     octstr_destroy(name);
  1012.     /* 
  1013.      * now check which type it is and process 
  1014.      *
  1015.      * valid tags at this level are:
  1016.      *   param [0]
  1017.      */
  1018.     if (i == 0) {
  1019.         /* this has been a <param> tag */
  1020.         if (parse_param(doc, node->xmlChildrenNode, msg, &n) == -1)
  1021.             return -1;
  1022.     } else {
  1023.         /* we should never be here */
  1024.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  1025.         (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_params!");
  1026.         return -1;
  1027.     }
  1028.     return 0;
  1029. }
  1032. static int parse_params(xmlDocPtr doc, xmlNodePtr node, 
  1033.                         XMLRPCMethodCall **msg)
  1034. {
  1035.     int status = 0;
  1036.   
  1037.     /* call for the parser function of the node type. */
  1038.     switch (node->type) {
  1040.         case XML_ELEMENT_NODE:
  1041.             status = parse_params_element(doc, node, msg);
  1042.             break;
  1044.         case XML_TEXT_NODE:
  1045.         case XML_COMMENT_NODE:
  1046.         case XML_PI_NODE:
  1047.             /* Text nodes, comments and PIs are ignored. */
  1048.             break;
  1049.    /*
  1050.     * XML has also many other node types, these are not needed with 
  1051.     * XML-RPC. Therefore they are assumed to be an error.
  1052.     */
  1053.         default:
  1054.             (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  1055.             (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown XML node in XML-RPC source.");
  1056.             return -1;
  1057.             break;
  1058.     }
  1060.     if (node->next != NULL)
  1061.    if (parse_params(doc, node->next, msg) == -1)
  1062.             return -1;
  1064.     return status;
  1065. }
  1068. static int parse_methodcall_element(xmlDocPtr doc, xmlNodePtr node, 
  1069.                                     XMLRPCMethodCall **msg)
  1070. {
  1071.     Octstr *name;
  1072.     Octstr *value;
  1073.     size_t i;
  1075.     /*
  1076.      * check if the element is allowed at this level 
  1077.      */
  1078.     name = octstr_create(node->name);
  1079.     if (octstr_len(name) == 0) {
  1080.         octstr_destroy(name);
  1081.         return -1;
  1082.     }
  1084.     i = 0;
  1085.     while (i < NUMBER_OF_METHODCALL_ELEMENTS) {
  1086.         if (octstr_case_compare(name, octstr_imm(methodcall_elements[i].name)) == 0)
  1087.             break;
  1088.         ++i;
  1089.     }
  1090.     if (i == NUMBER_OF_METHODCALL_ELEMENTS) {
  1091.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  1092.         (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' in XML source "
  1093.                                             "at level <methodCall>", octstr_get_cstr(name));
  1094.         octstr_destroy(name);
  1095.         return -1;
  1096.     } 
  1097.     octstr_destroy(name);
  1099.     /* 
  1100.      * now check which type it is and process 
  1101.      *
  1102.      * valid tags at this level are:
  1103.      *   methodCall [0]
  1104.      *   params     [1]
  1105.      */
  1106.     if (i == 0) {
  1107.         /* this has been the <methodName> tag */
  1108.         value = octstr_create(xmlNodeListGetString(doc, node->xmlChildrenNode, 1));
  1109.                 
  1110.         /* destroy current msg->method_name and redefine */
  1111.         octstr_destroy((*msg)->method_name);
  1112.         (*msg)->method_name = octstr_duplicate(value);
  1113.         octstr_destroy(value);
  1115.     } else {
  1116.         /* 
  1117.          * ok, this has to be an <params> tag, otherwise we would 
  1118.          * have returned previosly
  1119.          */
  1120.         if (parse_params(doc, node->xmlChildrenNode, msg) == -1)
  1121.             return -1;
  1122.     }
  1123.     return 0;
  1124. }
  1127. static int parse_methodcall(xmlDocPtr doc, xmlNodePtr node, 
  1128.                             XMLRPCMethodCall **msg)
  1129. {
  1130.     int status = 0;
  1131.   
  1132.     /* call for the parser function of the node type. */
  1133.     switch (node->type) {
  1135.         case XML_ELEMENT_NODE:
  1136.             status = parse_methodcall_element(doc, node, msg);
  1137.             break;
  1139.         case XML_TEXT_NODE:
  1140.         case XML_COMMENT_NODE:
  1141.         case XML_PI_NODE:
  1142.             /* Text nodes, comments and PIs are ignored. */
  1143.             break;
  1144.    /*
  1145.     * XML has also many other node types, these are not needed with 
  1146.     * XML-RPC. Therefore they are assumed to be an error.
  1147.     */
  1148.         default:
  1149.             (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  1150.             (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown XML node "
  1151.                                                 "in the XML-RPC source.");
  1152.             return -1;
  1153.             break;
  1154.     }
  1156.     if (node->next != NULL)
  1157.    if (parse_methodcall(doc, node->next, msg) == -1)
  1158.             return -1;
  1160.     return status;
  1161. }
  1163. static int parse_document(xmlDocPtr document, XMLRPCMethodCall **msg)
  1164. {
  1165.     xmlNodePtr node;
  1166.     Octstr *name;
  1168.     node = xmlDocGetRootElement(document);
  1170.     /*
  1171.      * check if this is at least a valid root element
  1172.      */
  1173.     name = octstr_create(node->name);
  1174.     if (octstr_len(name) == 0) {
  1175.         octstr_destroy(name);
  1176.         return -1;
  1177.     }
  1178.     if (octstr_case_compare(name, octstr_imm("METHODCALL")) != 0) {
  1179.         (*msg)->parse_status = XMLRPC_PARSING_FAILED;
  1180.         (*msg)->parse_error = octstr_format("XML-RPC compiler: wrong root element <%s>, "
  1181.                                             "<methodCall> expected!", 
  1182.                                             octstr_get_cstr(name));
  1183.         octstr_destroy(name);
  1184.         return -1;
  1185.     }
  1186.     octstr_destroy(name);
  1188.     return parse_methodcall(document, node->xmlChildrenNode, msg);
  1189. }