/* * gwlib/xmlrpc.c: functions to handle XML-RPC structure - building and parsing * * XML-RPC is HTTP-based XML defination to handle remote procedure calls, * and is defined at http://www.xml-rpc.org * * Kalle Marjola 2001 for project Kannel * Stipe Tolj <tolj@wapme-systems.de> */#include <libxml/xmlmemory.h>#include <libxml/tree.h>#include <libxml/debugXML.h>#include <libxml/encoding.h>#include "gwlib/gwlib.h"#include "gwlib/xmlrpc.h"struct xmlrpc_methodcall {    Octstr *method_name;    List *params;         /* List of XMLRPCValues */    int parse_status;     /* enum here */    Octstr *parse_error;  /* error string in case of parsing error */};struct xmlrpc_methodresponse {    XMLRPCValue *param;		/* either this... */    XMLRPCValue *fault; 	/* ..or this */};struct xmlrpc_value {    int v_type;		/* enum here */    XMLRPCScalar *v_scalar;    List *v_array;     /* List of XMLRPCValues */    List *v_struct;    /* List of XMLRPMembers */};struct xmlrpc_member {	/* member of struct */    Octstr *name;    XMLRPCValue *value;};struct xmlrpc_scalar {    int	s_type;		/* enum here */    Octstr *s_str;    long s_int;    int s_bool;    double s_double;    Octstr *s_date;    Octstr *s_base64;};struct xmlrpc_table_t {    char *name;};struct xmlrpc_2table_t {    char *name;    int s_type; /* enum here */};static xmlrpc_table_t methodcall_elements[] = {    { "METHODNAME" },    { "PARAMS" }};static xmlrpc_table_t params_elements[] = {    { "PARAM" }};static xmlrpc_table_t param_elements[] = {    { "VALUE" }};static xmlrpc_2table_t value_elements[] = {    { "I4", xr_int },    { "INT", xr_int },    { "BOOLEAN", xr_bool },    { "STRING", xr_string },    { "DOUBLE", xr_double },    { "DATETIME.ISO8601", xr_date },    { "BASE64", xr_base64 },    { "STRUCT", xr_struct },    { "ARRAY", xr_array }};static xmlrpc_table_t struct_elements[] = {    { "MEMBER" }};static xmlrpc_table_t member_elements[] = {    { "NAME" },    { "VALUE" }};#define NUMBER_OF_METHODCALL_ELEMENTS \    sizeof(methodcall_elements)/sizeof(methodcall_elements[0])#define NUMBER_OF_PARAMS_ELEMENTS \    sizeof(params_elements)/sizeof(params_elements[0])#define NUMBER_OF_PARAM_ELEMENTS \    sizeof(param_elements)/sizeof(param_elements[0])#define NUMBER_OF_VALUE_ELEMENTS \    sizeof(value_elements)/sizeof(value_elements[0])#define NUMBER_OF_STRUCT_ELEMENTS \    sizeof(struct_elements)/sizeof(struct_elements[0])#define NUMBER_OF_MEMBER_ELEMENTS \    sizeof(member_elements)/sizeof(member_elements[0])static int parse_document(xmlDocPtr document, XMLRPCMethodCall **msg);static int parse_methodcall(xmlDocPtr doc, xmlNodePtr node,                             XMLRPCMethodCall **msg);static int parse_methodcall_element(xmlDocPtr doc, xmlNodePtr node,                                     XMLRPCMethodCall **msg);static int parse_params(xmlDocPtr doc, xmlNodePtr node,                         XMLRPCMethodCall **msg);static int parse_params_element(xmlDocPtr doc, xmlNodePtr node,                                 XMLRPCMethodCall **msg);static int parse_param(xmlDocPtr doc, xmlNodePtr node,                        XMLRPCMethodCall **msg, int *n);static int parse_param_element(xmlDocPtr doc, xmlNodePtr node,                                XMLRPCMethodCall **msg);static int parse_value(xmlDocPtr doc, xmlNodePtr node,                        XMLRPCMethodCall **msg);static int parse_value_element(xmlDocPtr doc, xmlNodePtr node,                                XMLRPCMethodCall **msg);/*------------------------------------- * MethodCall */XMLRPCMethodCall *xmlrpc_call_create(Octstr *name){    XMLRPCMethodCall *nmsg = gw_malloc(sizeof(XMLRPCMethodCall));    nmsg->method_name = octstr_duplicate(name);    nmsg->params = list_create();    nmsg->parse_status = XMLRPC_COMPILE_OK;    nmsg->parse_error = NULL;        return nmsg;}XMLRPCMethodCall *xmlrpc_call_parse(Octstr *post_body){    XMLRPCMethodCall *msg = gw_malloc(sizeof(XMLRPCMethodCall));    xmlDocPtr pDoc;    size_t size;    char *body;    int ret;    msg->method_name = octstr_create("");    msg->params = list_create();    msg->parse_status = XMLRPC_COMPILE_OK;    msg->parse_error = NULL;    octstr_strip_blanks(post_body);    octstr_shrink_blanks(post_body);    size = octstr_len(post_body);    body = octstr_get_cstr(post_body);    /* parse XML document to a XML tree */    pDoc = xmlParseMemory(body, size);    ret = parse_document(pDoc, &msg);    xmlFreeDoc(pDoc);    return msg;}void xmlrpc_call_destroy(XMLRPCMethodCall *call){    if (call == NULL)	return;    octstr_destroy(call->method_name);    list_destroy(call->params, xmlrpc_value_destroy_item);    if (call->parse_error != NULL)        octstr_destroy(call->parse_error);    gw_free(call);}int xmlrpc_call_add_scalar(XMLRPCMethodCall *method, int type, void *arg){    XMLRPCValue *nval;    if (method == NULL)        return -1;    nval = xmlrpc_create_scalar_value(type, arg);    list_produce(method->params, nval);    return 0;}int xmlrpc_call_add_value(XMLRPCMethodCall *method, XMLRPCValue *value){    if (method == NULL || value == NULL)	return -1;    list_produce(method->params, value);    return 0;}Octstr *xmlrpc_call_octstr(XMLRPCMethodCall *call){    Octstr *body;    XMLRPCValue *val;    long i;        body = octstr_format("<?xml version=\"1.0\"?>\n<methodCall>\n"			             "  <methodName>%S</methodName>\n"			             "  <params>", call->method_name);    list_lock(call->params);    for (i = 0; i < list_len(call->params); i++) {        val = list_get(call->params, i);        octstr_format_append(body, "\n    <param>\n"                             "\n      ");        xmlrpc_value_print(val, body);        octstr_format_append(body, "\n    </param>\n");            }    list_unlock(call->params);        octstr_format_append(body, "  </params>\n"			             "</methodCall>\n");    return body;}int xmlrpc_call_send(XMLRPCMethodCall *call, HTTPCaller *http_ref,		     Octstr *url, List *headers, void *ref){    Octstr *body;    if (http_ref == NULL || call == NULL)	return -1;        if (headers == NULL)	headers = list_create();        http_header_add(headers, "Content-Type", "text/xml");    /*      * XML-RPC specs say we at least need Host and User-Agent      * HTTP headers to be defined.     * These are set anyway within gwlib/http.c:build_request()     */    body = xmlrpc_call_octstr(call);    http_start_request(http_ref, HTTP_METHOD_GET,                        url, headers, body, 0, ref, NULL);        octstr_destroy(body);    http_destroy_headers(headers);    return 0;}/*------------------------------------- * MethodResponse */XMLRPCMethodResponse *xmlrpc_response_create(XMLRPCValue *param){    XMLRPCMethodResponse *nmsg = gw_malloc(sizeof(XMLRPCMethodResponse));    nmsg->param = param;    nmsg->fault = NULL;        return nmsg;}void xmlrpc_response_destroy(XMLRPCMethodResponse *response){    if (response == NULL)	return;    xmlrpc_value_destroy(response->param);    xmlrpc_value_destroy(response->fault);    gw_free(response);}/* Create new value. Set type of it to undefined, so it must be * set laterwards to correct one */XMLRPCValue *xmlrpc_value_create(void){    XMLRPCValue *val = gw_malloc(sizeof(XMLRPCValue));    val->v_type = xr_undefined;    val->v_scalar = NULL;    val->v_array = NULL;    val->v_struct = NULL;    return val;}/* Destroy value with its information, recursively if need to */void xmlrpc_value_destroy(XMLRPCValue *val){    if (val == NULL)	return;    switch(val->v_type) {    case xr_scalar:	xmlrpc_scalar_destroy(val->v_scalar);	break;    case xr_array:	list_destroy(val->v_array, xmlrpc_value_destroy_item);	break;    case xr_struct:	list_destroy(val->v_struct, xmlrpc_member_destroy_item);	break;    }    gw_free(val);}/* wrapper to destroy to be used with list */void xmlrpc_value_destroy_item(void *val){    xmlrpc_value_destroy(val);}void xmlrpc_value_print(XMLRPCValue *val, Octstr *os){    if (val->v_type != xr_scalar)	return;    octstr_format_append(os, "<value>");    xmlrpc_scalar_print(val->v_scalar, os);    octstr_format_append(os, "</value>");}/* Create new member with undefined value */XMLRPCMember *xmlrpc_member_create(Octstr *name){    XMLRPCMember *member = gw_malloc(sizeof(XMLRPCMember));    gw_assert(name);    member->name = octstr_duplicate(name);    member->value = xmlrpc_value_create();    return member;}/* Destroy member and its contents */void xmlrpc_member_destroy(XMLRPCMember *member){    if (member == NULL)	return;    xmlrpc_value_destroy(member->value);    octstr_destroy(member->name);    gw_free(member);}void xmlrpc_member_destroy_item(void *member){    xmlrpc_member_destroy(member);}/* Create new scalar of given type with given argument */XMLRPCScalar *xmlrpc_scalar_create(int type, void *arg){    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_int:            scalar->s_int = (long)arg;            break;        case xr_bool:            scalar->s_bool = (int)arg;            break;        case xr_string:            scalar->s_str = octstr_duplicate((Octstr *)arg);            break;        case xr_date:            scalar->s_date = octstr_duplicate((Octstr *)arg);            break;        case xr_base64:            scalar->s_base64 = octstr_duplicate((Octstr *)arg);            break;        default:            panic(0,"XML-RPC: scalar type not supported!");