xmlrpc.c File Reference

#include <inttypes.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/debugXML.h>
#include <libxml/encoding.h>
#include "gwlib/gwlib.h"
#include "gwlib/xmlrpc.h"

Go to the source code of this file.

Data Structures
struct	xmlrpc_methodcall
struct	xmlrpc_methodresponse
struct	xmlrpc_fault
struct	xmlrpc_document
struct	xmlrpc_value
struct	xmlrpc_member
struct	xmlrpc_scalar
struct	xmlrpc_table_t
struct	xmlrpc_2table_t

Macros
#define	XR_ENABLE_EMPTY_STRING_VALUES
#define	OPTIMAL_STRUCT_SIZE   7
#define	NUMBER_OF_METHODCALL_ELEMENTS   sizeof(methodcall_elements)/sizeof(methodcall_elements[0])
#define	NUMBER_OF_METHODRESPONSE_ELEMENTS   sizeof(methodresponse_elements)/sizeof(methodresponse_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])
#define	NUMBER_OF_ARRAY_ELEMENTS   sizeof(array_elements)/sizeof(array_elements[0])
#define	NUMBER_OF_DATA_ELEMENTS   sizeof(data_elements)/sizeof(data_elements[0])
#define	NUMBER_OF_FAULT_ELEMENTS   sizeof(fault_elements)/sizeof(fault_elements[0])

Typedefs
typedef struct xmlrpc_methodresponse	XMLRPCMethodResponse
typedef struct xmlrpc_member	XMLRPCMember
typedef struct xmlrpc_methodcall	XMLRPCMethodCall
typedef struct xmlrpc_fault	XMLRPCFault
typedef struct xmlrpc_table_t	xmlrpc_table_t
typedef struct xmlrpc_2table_t	xmlrpc_2table_t

Functions
static int	parse_document (xmlDocPtr document, XMLRPCDocument *xrdoc)
static int	parse_methodcall (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCMethodCall *methodcall)
static int	parse_methodcall_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCMethodCall *methodcall)
static int	parse_methodresponse (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCMethodResponse *methodresponse, int *n)
static int	parse_methodresponse_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCMethodResponse *methodresponse)
static int	parse_params (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, List *params)
static int	parse_params_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, List *params)
static int	parse_param (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, List *params, int *n)
static int	parse_param_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, List *params)
static int	parse_value (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCValue *value)
static int	parse_value_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCValue *xrvalue)
static int	parse_struct (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, Dict *members)
static int	parse_struct_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, Dict *members)
static int	parse_member (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCMember *member)
static int	parse_member_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCMember *member)
static int	parse_array (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, List *elements)
static int	parse_array_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, List *elements)
static int	parse_data (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, List *elements)
static int	parse_data_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, List *elements)
static int	parse_fault (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCFault *fault)
static int	parse_fault_element (xmlDocPtr doc, xmlNodePtr node, XMLRPCDocument *xrdoc, XMLRPCFault *fault)
static XMLRPCMethodCall *	xmlrpc_call_create (Octstr *name)
static void	xmlrpc_call_destroy (XMLRPCMethodCall *call)
static Octstr *	xmlrpc_call_get_name (XMLRPCMethodCall *call)
static int	xmlrpc_call_add_param (XMLRPCMethodCall *method, XMLRPCValue *value)
static Octstr *	xmlrpc_call_print (XMLRPCMethodCall *call, int level)
static XMLRPCFault *	xmlrpc_fault_create (long fcode, Octstr *fstring)
static void	xmlrpc_fault_destroy (XMLRPCFault *fault)
static long	xmlrpc_fault_get_code (XMLRPCFault *fault)
static Octstr *	xmlrpc_fault_get_string (XMLRPCFault *fault)
static Octstr *	xmlrpc_fault_print (XMLRPCFault *fault, int level)
static XMLRPCMethodResponse *	xmlrpc_response_create (void)
static void	xmlrpc_response_destroy (XMLRPCMethodResponse *response)
static int	xmlrpc_response_add_param (XMLRPCMethodResponse *response, XMLRPCValue *value)
static int	xmlrpc_response_is_fault (XMLRPCMethodResponse *response)
static long	xmlrpc_response_get_faultcode (XMLRPCMethodResponse *faultresponse)
static Octstr *	xmlrpc_response_get_faultstring (XMLRPCMethodResponse *faultresponse)
static Octstr *	xmlrpc_response_print (XMLRPCMethodResponse *response, int level)
XMLRPCDocument *	xmlrpc_doc_create (void)
XMLRPCDocument *	xmlrpc_doc_create_call (Octstr *name)
XMLRPCDocument *	xmlrpc_doc_create_response (void)
XMLRPCDocument *	xmlrpc_doc_create_faultresponse (long faultcode, Octstr *faultstring)
XMLRPCDocument *	xmlrpc_doc_parse (Octstr *post_body, int d_type)
void	xmlrpc_doc_destroy (XMLRPCDocument *xrdoc, int d_type)
int	xmlrpc_doc_add_value (XMLRPCDocument *xrdoc, int d_type, XMLRPCValue *value)
int	xmlrpc_doc_add_scalar (XMLRPCDocument *xrdoc, int d_type, int type, void *arg)
Octstr *	xmlrpc_doc_print (XMLRPCDocument *xrdoc, int d_type, int level)
int	xmlrpc_doc_send (XMLRPCDocument *xrdoc, int d_type, HTTPCaller *http_ref, Octstr *url, List *headers, void *ref)
XMLRPCValue *	xmlrpc_value_create (void)
void	xmlrpc_value_destroy (XMLRPCValue *val)
void	xmlrpc_value_destroy_item (void *val)
int	xmlrpc_value_set_type (XMLRPCValue *val, int v_type)
int	xmlrpc_value_set_content (XMLRPCValue *val, void *content)
int	xmlrpc_value_get_type (XMLRPCValue *val)
int	xmlrpc_value_get_type_smart (XMLRPCValue *val)
void *	xmlrpc_value_get_content (XMLRPCValue *val)
Octstr *	xmlrpc_value_print (XMLRPCValue *val, int level)
XMLRPCScalar *	xmlrpc_scalar_create (int type, void *arg)
void	xmlrpc_scalar_destroy (XMLRPCScalar *scalar)
int	xmlrpc_scalar_get_type (XMLRPCScalar *scalar)
void *	xmlrpc_scalar_get_content (XMLRPCScalar *scalar, int s_type)
Octstr *	xmlrpc_scalar_print (XMLRPCScalar *scalar, int level)
static XMLRPCMember *	xmlrpc_member_create (void)
static void	xmlrpc_member_destroy (XMLRPCMember *member, int destroy_value)
Octstr *	xmlrpc_get_call_name (XMLRPCDocument *call)
int	xmlrpc_count_params (XMLRPCDocument *xrdoc)
XMLRPCValue *	xmlrpc_get_param (XMLRPCDocument *xrdoc, int i)
int	xmlrpc_get_type_param (XMLRPCDocument *xrdoc, int i)
void *	xmlrpc_get_content_param (XMLRPCDocument *xrdoc, int i)
XMLRPCValue *	xmlrpc_create_struct_value (int count_members)
long	xmlrpc_count_members (XMLRPCValue *xrstruct)
int	xmlrpc_add_member (XMLRPCValue *xrstruct, Octstr *name, XMLRPCValue *value)
int	xmlrpc_add_member_scalar (XMLRPCValue *xrstruct, Octstr *name, int type, void *arg)
XMLRPCValue *	xmlrpc_get_member (XMLRPCValue *xrstruct, Octstr *name)
int	xmlrpc_get_member_type (XMLRPCValue *xrstruct, Octstr *name)
void *	xmlrpc_get_member_content (XMLRPCValue *xrstruct, Octstr *name)
Octstr *	xmlrpc_print_struct (Dict *v_struct, int level)
XMLRPCValue *	xmlrpc_create_array_value (void)
int	xmlrpc_count_elements (XMLRPCValue *xrarray)
int	xmlrpc_add_element (XMLRPCValue *xrarray, XMLRPCValue *value)
int	xmlrpc_add_element_scalar (XMLRPCValue *xrarray, int type, void *arg)
XMLRPCValue *	xmlrpc_get_element (XMLRPCValue *xrarray, int i)
int	xmlrpc_get_element_type (XMLRPCValue *xrarray, int i)
void *	xmlrpc_get_element_content (XMLRPCValue *xrarray, int i)
Octstr *	xmlrpc_print_array (List *v_array, int level)
XMLRPCValue *	xmlrpc_create_scalar_value (int type, void *arg)
XMLRPCValue *	xmlrpc_create_double_value (double val)
XMLRPCValue *	xmlrpc_create_int_value (long val)
XMLRPCValue *	xmlrpc_create_string_value (Octstr *val)
int	xmlrpc_is_fault (XMLRPCDocument *response)
long	xmlrpc_get_faultcode (XMLRPCDocument *faultresponse)
Octstr *	xmlrpc_get_faultstring (XMLRPCDocument *faultresponse)
int	xmlrpc_parse_status (XMLRPCDocument *xrdoc)
Octstr *	xmlrpc_parse_error (XMLRPCDocument *xrdoc)

Variables
static xmlrpc_table_t	methodcall_elements []
static xmlrpc_table_t	methodresponse_elements []
static xmlrpc_table_t	params_elements []
static xmlrpc_table_t	param_elements []
static xmlrpc_2table_t	value_elements []
static xmlrpc_table_t	struct_elements []
static xmlrpc_table_t	member_elements []
static xmlrpc_table_t	array_elements []
static xmlrpc_table_t	data_elements []
static xmlrpc_table_t	fault_elements []

Macro Definition Documentation

NUMBER_OF_ARRAY_ELEMENTS

#define NUMBER_OF_ARRAY_ELEMENTS   sizeof(array_elements)/sizeof(array_elements[0])

Definition at line 209 of file xmlrpc.c.

Referenced by parse_array_element().

NUMBER_OF_DATA_ELEMENTS

#define NUMBER_OF_DATA_ELEMENTS   sizeof(data_elements)/sizeof(data_elements[0])

Definition at line 211 of file xmlrpc.c.

Referenced by parse_data_element().

NUMBER_OF_FAULT_ELEMENTS

#define NUMBER_OF_FAULT_ELEMENTS   sizeof(fault_elements)/sizeof(fault_elements[0])

Definition at line 213 of file xmlrpc.c.

Referenced by parse_fault_element().

NUMBER_OF_MEMBER_ELEMENTS

#define NUMBER_OF_MEMBER_ELEMENTS   sizeof(member_elements)/sizeof(member_elements[0])

Definition at line 207 of file xmlrpc.c.

Referenced by parse_member_element().

NUMBER_OF_METHODCALL_ELEMENTS

#define NUMBER_OF_METHODCALL_ELEMENTS   sizeof(methodcall_elements)/sizeof(methodcall_elements[0])

Definition at line 195 of file xmlrpc.c.

Referenced by parse_methodcall_element().

NUMBER_OF_METHODRESPONSE_ELEMENTS

#define NUMBER_OF_METHODRESPONSE_ELEMENTS   sizeof(methodresponse_elements)/sizeof(methodresponse_elements[0])

Definition at line 197 of file xmlrpc.c.

Referenced by parse_methodresponse_element().

NUMBER_OF_PARAM_ELEMENTS

#define NUMBER_OF_PARAM_ELEMENTS   sizeof(param_elements)/sizeof(param_elements[0])

Definition at line 201 of file xmlrpc.c.

Referenced by parse_param_element().

NUMBER_OF_PARAMS_ELEMENTS

#define NUMBER_OF_PARAMS_ELEMENTS   sizeof(params_elements)/sizeof(params_elements[0])

Definition at line 199 of file xmlrpc.c.

Referenced by parse_params_element().

NUMBER_OF_STRUCT_ELEMENTS

#define NUMBER_OF_STRUCT_ELEMENTS   sizeof(struct_elements)/sizeof(struct_elements[0])

Definition at line 205 of file xmlrpc.c.

Referenced by parse_struct_element().

NUMBER_OF_VALUE_ELEMENTS

#define NUMBER_OF_VALUE_ELEMENTS   sizeof(value_elements)/sizeof(value_elements[0])

Definition at line 203 of file xmlrpc.c.

Referenced by parse_value_element().

OPTIMAL_STRUCT_SIZE

#define OPTIMAL_STRUCT_SIZE   7

Definition at line 79 of file xmlrpc.c.

Referenced by parse_value_element(), and xmlrpc_create_struct_value().

XR_ENABLE_EMPTY_STRING_VALUES

#define XR_ENABLE_EMPTY_STRING_VALUES

Definition at line 77 of file xmlrpc.c.

Typedef Documentation

xmlrpc_2table_t

typedef struct xmlrpc_2table_t xmlrpc_2table_t

Definition at line 87 of file xmlrpc.c.

xmlrpc_table_t

typedef struct xmlrpc_table_t xmlrpc_table_t

Definition at line 86 of file xmlrpc.c.

XMLRPCFault

typedef struct xmlrpc_fault XMLRPCFault

Definition at line 84 of file xmlrpc.c.

XMLRPCMember

typedef struct xmlrpc_member XMLRPCMember

Definition at line 82 of file xmlrpc.c.

XMLRPCMethodCall

typedef struct xmlrpc_methodcall XMLRPCMethodCall

Definition at line 83 of file xmlrpc.c.

XMLRPCMethodResponse

typedef struct xmlrpc_methodresponse XMLRPCMethodResponse

Definition at line 81 of file xmlrpc.c.

Function Documentation

parse_array()

static int parse_array ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, List *  elements  )

static

Definition at line 2288 of file xmlrpc.c.

References octstr_format(), parse_array_element(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, and XMLRPC_PARSING_FAILED.

Referenced by parse_value_element().

{
    int status = 0;
  
    if (node == NULL)
        return -1;

    /* call for the parser function of the node type. */
    switch (node->type) {

        case XML_ELEMENT_NODE:
            status = parse_array_element(doc, node, xrdoc, elements);
            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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
            return -1;
            break;
    }

    if (node->next != NULL)
        if (parse_array(doc, node->next, xrdoc, elements) == -1)
            return -1;

    return status;
}

parse_array_element()

static int parse_array_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, List *  elements  )

static

Definition at line 2326 of file xmlrpc.c.

References array_elements, error(), name, NUMBER_OF_ARRAY_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), parse_data(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, XMLRPC_PARSING_FAILED, and XMLRPC_XMLPARSE_FAILED.

Referenced by parse_array().

{
    Octstr *name;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML array element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }

    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }

    i = 0;
    while (i < NUMBER_OF_ARRAY_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(array_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_ARRAY_ELEMENTS) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
                                           "in XML source at level <array>", 
                                           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:
     *   data [0]
     */
    if (i == 0) {
        /* this has been a <data> tag */
        if (parse_data(doc, node->xmlChildrenNode, xrdoc, elements) == -1)
            return -1;
            
    } else {
        /* we should never be here */
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_array!");
        return -1;
    }
    return 0;
}

parse_data()

static int parse_data ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, List *  elements  )

static

Definition at line 2384 of file xmlrpc.c.

References octstr_format(), parse_data_element(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, and XMLRPC_PARSING_FAILED.

Referenced by parse_array_element().

{
    int status = 0;
  
    /* call for the parser function of the node type. */
    switch (node->type) {

        case XML_ELEMENT_NODE:
            status = parse_data_element(doc, node, xrdoc, elements);
            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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
            return -1;
            break;
    }

    if (node->next != NULL)
           if (parse_data(doc, node->next, xrdoc, elements) == -1)
            return -1;

    return status;
}

parse_data_element()

static int parse_data_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, List *  elements  )

static

Definition at line 2419 of file xmlrpc.c.

References data_elements, error(), gwlist_append(), name, NUMBER_OF_DATA_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, parse_value(), XMLRPC_PARSING_FAILED, xmlrpc_value_create(), xmlrpc_value_destroy(), and XMLRPC_XMLPARSE_FAILED.

Referenced by parse_data().

{
    Octstr *name;
    XMLRPCValue *value;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML data element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }

    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }

    i = 0;
    while (i < NUMBER_OF_DATA_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(data_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_DATA_ELEMENTS) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
                                           "in XML source at level <data>", 
                                           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 <value> tag */
        value = xmlrpc_value_create();
        if (parse_value(doc, node->xmlChildrenNode, xrdoc, value) == -1) {
            xmlrpc_value_destroy(value);
            return -1;
        }
        gwlist_append(elements, value);
            
    } else {
        /* we should never be here */
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_array!");
        return -1;
    }
    return 0;
}

parse_document()

static int parse_document ( xmlDocPtr  document, XMLRPCDocument *  xrdoc  )

static

Definition at line 1369 of file xmlrpc.c.

References xmlrpc_document::d_type, error(), xmlrpc_methodcall::method_name, xmlrpc_document::methodcall, xmlrpc_document::methodresponse, name, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), xmlrpc_document::parse_error, parse_methodcall(), parse_methodresponse(), xmlrpc_document::parse_status, xmlrpc_call_create(), xmlrpc_call_destroy(), XMLRPC_COMPILE_OK, XMLRPC_PARSING_FAILED, xmlrpc_response_create(), xmlrpc_response_destroy(), XMLRPC_XMLPARSE_FAILED, xr_methodcall, xr_methodresponse, and xr_undefined.

Referenced by xmlrpc_doc_parse().

{
    xmlNodePtr node;
    Octstr *name;
    int n = 0, status = 0;
    
    node = xmlDocGetRootElement(document);

    /*
     * check if this is at least a valid root element
     */
    if (node == NULL || node->name == NULL) {
        error(0, "XMLRPC: XML document - not valid root node!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }
    
    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }
    if ((xrdoc->d_type == xr_methodcall || xrdoc->d_type == xr_undefined)
        && octstr_case_compare(name, octstr_imm("METHODCALL")) == 0) {
        
        xrdoc->d_type = xr_methodcall;
        xrdoc->methodcall = xmlrpc_call_create(NULL);
        octstr_destroy(name);
        
        status = parse_methodcall(document, node->xmlChildrenNode, xrdoc, xrdoc->methodcall);
        if (status < 0) {
            xmlrpc_call_destroy(xrdoc->methodcall);
            xrdoc->methodcall = NULL;
            if (xrdoc->parse_status == XMLRPC_COMPILE_OK) {
                xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
                xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
            }
        } 
        else if ((xrdoc->methodcall->method_name) == NULL) {
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: <methodName> tag expected!");
            status = -1;
        }
        return status;
    } else if ((xrdoc->d_type == xr_methodresponse || xrdoc->d_type == xr_undefined)
               && octstr_case_compare(name, octstr_imm("METHODRESPONSE")) == 0) {
        
        xrdoc->d_type = xr_methodresponse;
        xrdoc->methodresponse = xmlrpc_response_create();
        octstr_destroy(name);
        
        status = parse_methodresponse(document, node->xmlChildrenNode, 
                                      xrdoc, xrdoc->methodresponse, &n);
        if (status < 0) {
            xmlrpc_response_destroy(xrdoc->methodresponse);
            xrdoc->methodresponse = NULL;
        }
        return status;
    } else {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: wrong root element <%s>, "
                                           "<%s> expected!", 
                                           octstr_get_cstr(name), 
                                           (xrdoc->d_type == xr_methodcall ? 
                                               "methodCall" : "methodResponse"));
        octstr_destroy(name);
        return -1;
    }
}

parse_fault()

static int parse_fault ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCFault *  fault  )

static

Definition at line 2482 of file xmlrpc.c.

References octstr_format(), xmlrpc_document::parse_error, parse_fault_element(), xmlrpc_document::parse_status, and XMLRPC_PARSING_FAILED.

Referenced by parse_methodresponse_element().

{
    int status = 0;
  
    /* call for the parser function of the node type. */
    switch (node->type) {

        case XML_ELEMENT_NODE:
            status = parse_fault_element(doc, node, xrdoc, fault);
            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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");
            return -1;
            break;
    }

    if (node->next != NULL)
           if (parse_fault(doc, node->next, xrdoc, fault) == -1)
            return -1;

    return status;
}

parse_fault_element()

static int parse_fault_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCFault *  fault  )

static

Definition at line 2517 of file xmlrpc.c.

References error(), xmlrpc_fault::f_code, xmlrpc_fault::f_string, fault_elements, name, NUMBER_OF_FAULT_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, parse_value(), xmlrpc_count_members(), xmlrpc_get_member(), XMLRPC_PARSING_FAILED, xmlrpc_scalar_get_int, xmlrpc_scalar_get_string, xmlrpc_value_create(), xmlrpc_value_destroy(), xmlrpc_value_get_content(), xmlrpc_value_get_type(), xmlrpc_value_get_type_smart(), XMLRPC_XMLPARSE_FAILED, xr_int, xr_string, and xr_struct.

Referenced by parse_fault().

{
    Octstr *name; 
    XMLRPCValue *value, *v_code, *v_string;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML fault element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }

    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }

    i = 0;
    while (i < NUMBER_OF_FAULT_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(fault_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_FAULT_ELEMENTS) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "
                                           "in XML source at level <fault>", 
                                           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 <value> tag */
        value = xmlrpc_value_create();
        if (parse_value(doc, node->xmlChildrenNode, xrdoc, value) == -1) {
            xmlrpc_value_destroy(value);
            return -1;    
        }
        /* must be :
         *     <struct>
         *         <member>
         *             <name>faultCode</name>
         *             <value><int> ... </int></value>
         *         </member>
         *         <member>
         *             <name>faultString</name>
         *             <value><string> ... </string></value>
         *         </member>
         *     </struct> 
         */
        if (xmlrpc_value_get_type(value) != xr_struct ||
            (v_code = xmlrpc_get_member(value, octstr_imm("faultCode"))) == NULL ||
            xmlrpc_value_get_type_smart(v_code) != xr_int ||
            (v_string = xmlrpc_get_member(value, octstr_imm("faultString"))) == NULL ||
            xmlrpc_value_get_type_smart(v_string) != xr_string ||
            xmlrpc_count_members(value) != 2) {
            
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: bogus value "
                                               "in XML source at level <fault>");
            xmlrpc_value_destroy(value);
            return -1;
        }
        
        fault->f_code = xmlrpc_scalar_get_int((XMLRPCScalar *) xmlrpc_value_get_content(v_code));
        fault->f_string = xmlrpc_scalar_get_string((XMLRPCScalar *) xmlrpc_value_get_content(v_string));
        
        xmlrpc_value_destroy(value);
    } else {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: duplicated tag '<name>' "
                                           "in XML source at level <member>");
        return -1;
    }
    return 0;
}

parse_member()

static int parse_member ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCMember *  member  )

static

Definition at line 2178 of file xmlrpc.c.

References octstr_format(), xmlrpc_document::parse_error, parse_member_element(), xmlrpc_document::parse_status, and XMLRPC_PARSING_FAILED.

Referenced by parse_struct_element().

{
    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, xrdoc, member);
            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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->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, xrdoc, member) == -1)
            return -1;

    return status;
}

parse_member_element()

static int parse_member_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCMember *  member  )

static

Definition at line 2213 of file xmlrpc.c.

References error(), member_elements, xmlrpc_member::name, name, NUMBER_OF_MEMBER_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, parse_value(), xmlrpc_member::value, XMLRPC_PARSING_FAILED, xmlrpc_value_create(), xmlrpc_value_destroy(), and XMLRPC_XMLPARSE_FAILED.

Referenced by parse_member().

{
    Octstr *name;
    xmlChar *content_buff;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML member element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }

    name = octstr_create((const char*)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) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->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 <name> tag */
        if (member->name != NULL) {
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: duplicated tag '<name>' "
                                               "in XML source at level <member>");
            return -1;
        }
        content_buff = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
        if (content_buff != NULL) {
            member->name = octstr_create((const char*)content_buff);
            xmlFree(content_buff);
        } else {
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: empty tag <name> in XML source "
                                          "at level <member>");
            return -1;
        }
    } else {
        member->value = xmlrpc_value_create();
        if (parse_value(doc, node->xmlChildrenNode, xrdoc, member->value) == -1) {
            xmlrpc_value_destroy(member->value);
            member->value = NULL;
            return -1;    
        }
    }
    return 0;
}

parse_methodcall()

static int parse_methodcall ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCMethodCall *  methodcall  )

static

Definition at line 1440 of file xmlrpc.c.

References octstr_format(), xmlrpc_document::parse_error, parse_methodcall_element(), xmlrpc_document::parse_status, and XMLRPC_PARSING_FAILED.

Referenced by parse_document().

{
    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, xrdoc, methodcall);
            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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: unknown XML node "
                                               "in the XML-RPC source.");
            return -1;
            break;
    }

    if (node->next != NULL)
        return parse_methodcall(doc, node->next, xrdoc, methodcall);
        
    return status;
}

parse_methodcall_element()

static int parse_methodcall_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCMethodCall *  methodcall  )

static

Definition at line 1476 of file xmlrpc.c.

References error(), xmlrpc_methodcall::method_name, methodcall_elements, name, NUMBER_OF_METHODCALL_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), xmlrpc_methodcall::params, xmlrpc_document::parse_error, parse_params(), xmlrpc_document::parse_status, XMLRPC_PARSING_FAILED, and XMLRPC_XMLPARSE_FAILED.

Referenced by parse_methodcall().

{
    Octstr *name;
    xmlChar *content_buff;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML methodcall element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }

    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) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->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:
     *   methodName [0]
     *   params     [1]
     */
    if (i == 0) {
        /* this has been the <methodName> tag */
        if (methodcall->method_name == NULL) {
            /*only one <methodName> tag allowed*/
            content_buff = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
            if (content_buff != NULL) {
                methodcall->method_name = octstr_create(content_buff);
                xmlFree(content_buff);
            } else {
                xrdoc->parse_status = XMLRPC_PARSING_FAILED;
                xrdoc->parse_error = octstr_format("XML-RPC compiler: empty tag <methodName> in XML source "
                                           "at level <methodCall>");
                return -1;
            }
        } else {
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: duplicated tag <methodName> in XML source "
                                               "at level <methodCall>");
            octstr_destroy(name);
            return -1;
        }
    } else {
        /* 
         * ok, this has to be an <params> tag, otherwise we would 
         * have returned previosly
         */
        return parse_params(doc, node->xmlChildrenNode, xrdoc, methodcall->params);
    }
    return 0;
} 

parse_methodresponse()

static int parse_methodresponse ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCMethodResponse *  methodresponse, int *  n  )

static

Definition at line 1552 of file xmlrpc.c.

References octstr_format(), xmlrpc_document::parse_error, parse_methodresponse_element(), xmlrpc_document::parse_status, and XMLRPC_PARSING_FAILED.

Referenced by parse_document().

{
    int status = 0;
  
    /* call for the parser function of the node type. */
    switch (node->type) {

        case XML_ELEMENT_NODE:
            if (*n > 0) {
                xrdoc->parse_status = XMLRPC_PARSING_FAILED;
                xrdoc->parse_error = octstr_format("XML-RPC compiler: unexpected XML node <%s> "
                                                   "in the XML-RPC source.", node->name);
                return -1;
            }
            status = parse_methodresponse_element(doc, node, xrdoc, methodresponse);
            (*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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: unknown XML node "
                                               "in the XML-RPC source.");
            return -1;
            break;
    }

    if (node->next != NULL) {
        if (parse_methodresponse(doc, node->next, xrdoc, methodresponse, n) == -1) {
            return -1;
        }
    }

    return status;
}

parse_methodresponse_element()

static int parse_methodresponse_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCMethodResponse *  methodresponse  )

static

Definition at line 1597 of file xmlrpc.c.

References error(), xmlrpc_methodresponse::fault, gwlist_consume(), gwlist_create, gwlist_destroy(), gwlist_len(), methodresponse_elements, name, NUMBER_OF_METHODRESPONSE_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), xmlrpc_methodresponse::param, xmlrpc_document::parse_error, parse_fault(), parse_params(), xmlrpc_document::parse_status, xmlrpc_fault_create(), XMLRPC_PARSING_FAILED, xmlrpc_value_destroy_item(), and XMLRPC_XMLPARSE_FAILED.

Referenced by parse_methodresponse().

{
    Octstr *name;
    size_t i;
    int status;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML methodResponse element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }

    name = octstr_create(node->name);
    if (octstr_len(name) == 0) {
        octstr_destroy(name);
        return -1;
    }

    i = 0;
    while (i < NUMBER_OF_METHODRESPONSE_ELEMENTS) {
        if (octstr_case_compare(name, octstr_imm(methodresponse_elements[i].name)) == 0)
            break;
        ++i;
    }
    if (i == NUMBER_OF_METHODRESPONSE_ELEMENTS) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' in XML source "
                                           "at level <methodResponse>", 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:
     *   fault  [0]
     *   params [1]
     */
    if (i == 0) {
        /* this has been the <fault> tag */
        methodresponse->fault = xmlrpc_fault_create(0, NULL);
        return parse_fault(doc, node->xmlChildrenNode, xrdoc, methodresponse->fault);
    } else {
        /* 
         * ok, this has to be an <params> tag, otherwise we would 
         * have returned previosly
         */
        List *params = gwlist_create();;
        status = parse_params(doc, node->xmlChildrenNode, xrdoc, params);
        if (status < 0) return -1;
        if (gwlist_len(params) != 1) {
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler:wrong number of params "
                                               "at level <methodResponse>");
            gwlist_destroy(params, xmlrpc_value_destroy_item);
            return -1;
        }
        methodresponse->param = gwlist_consume(params);
        gwlist_destroy(params, xmlrpc_value_destroy_item);
        return status;
    }

}

parse_param()

static int parse_param ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, List *  params, int *  n  )

static

Definition at line 1762 of file xmlrpc.c.

References octstr_format(), xmlrpc_document::parse_error, parse_param_element(), xmlrpc_document::parse_status, and XMLRPC_PARSING_FAILED.

Referenced by parse_params_element().

{
    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) {
                xrdoc->parse_status = XMLRPC_PARSING_FAILED;
                xrdoc->parse_error = octstr_format("XML-RPC compiler: param may only have one value!");
                return -1;
            }

            status = parse_param_element(doc, node, xrdoc, params);
            (*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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->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, xrdoc, params, n) == -1)
            return -1;

    return status;
}

parse_param_element()

static int parse_param_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, List *  params  )

static

Definition at line 1806 of file xmlrpc.c.

References error(), gwlist_append(), name, NUMBER_OF_PARAM_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), param_elements, xmlrpc_document::parse_error, xmlrpc_document::parse_status, parse_value(), XMLRPC_PARSING_FAILED, xmlrpc_value_create(), xmlrpc_value_destroy(), and XMLRPC_XMLPARSE_FAILED.

Referenced by parse_param().

{
    Octstr *name;
    size_t i;
    XMLRPCValue *value;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML param element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }

    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) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->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 */
        value = xmlrpc_value_create();
        if (parse_value(doc, node->xmlChildrenNode, xrdoc, value) == -1) {
            xmlrpc_value_destroy(value);
            return -1;
        }
        gwlist_append(params, value);
    } else {
        /* we should never be here */
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_param!");
        return -1;
    }
    return 0;
}

parse_params()

static int parse_params ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, List *  params  )

static

Definition at line 1668 of file xmlrpc.c.

References octstr_format(), xmlrpc_document::parse_error, parse_params_element(), xmlrpc_document::parse_status, and XMLRPC_PARSING_FAILED.

Referenced by parse_methodcall_element(), and parse_methodresponse_element().

{
    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, xrdoc, params);
            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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->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, xrdoc, params) == -1)
            return -1;

    return status;
}

parse_params_element()

static int parse_params_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, List *  params  )

static

Definition at line 1703 of file xmlrpc.c.

References error(), name, NUMBER_OF_PARAMS_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), params_elements, xmlrpc_document::parse_error, parse_param(), xmlrpc_document::parse_status, XMLRPC_PARSING_FAILED, and XMLRPC_XMLPARSE_FAILED.

Referenced by parse_params().

{
    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>
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML params element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }
    
    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) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->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, xrdoc, params, &n) == -1)
            return -1;
    } else {
        /* we should never be here */
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_params!");
        return -1;
    }
    return 0;
}

parse_struct()

static int parse_struct ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, Dict *  members  )

static

Definition at line 2072 of file xmlrpc.c.

References octstr_format(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, parse_struct_element(), and XMLRPC_PARSING_FAILED.

Referenced by parse_value_element().

{
    int status = 0;
  
    if (node == NULL)
        return -1;

    /* call for the parser function of the node type. */
    switch (node->type) {

        case XML_ELEMENT_NODE:
            status = parse_struct_element(doc, node, xrdoc, members);
            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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->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, xrdoc, members) == -1)
            return -1;

    return status;
}

parse_struct_element()

static int parse_struct_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, Dict *  members  )

static

Definition at line 2110 of file xmlrpc.c.

References dict_put_once(), error(), xmlrpc_member::name, name, NUMBER_OF_STRUCT_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), xmlrpc_document::parse_error, parse_member(), xmlrpc_document::parse_status, struct_elements, xmlrpc_member::value, xmlrpc_member_create(), xmlrpc_member_destroy(), XMLRPC_PARSING_FAILED, and XMLRPC_XMLPARSE_FAILED.

Referenced by parse_struct().

{
    Octstr *name;
    size_t i;
    XMLRPCMember *member;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML struct element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }
    
    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) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->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 */
        member = xmlrpc_member_create();
        if (parse_member(doc, node->xmlChildrenNode, xrdoc, member) == -1) {
            xmlrpc_member_destroy(member, 1);
            return -1;
        }
        if (! dict_put_once(members, member->name, member->value)) {
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->parse_error = octstr_format("XML-RPC compiler: at least two members have same name.");
            xmlrpc_member_destroy(member, 1);
            return -1;
        }
        xmlrpc_member_destroy(member, 0);
    } else {
        /* we should never be here */
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_struct!");
        return -1;
    }
    return 0;
}

parse_value()

static int parse_value ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCValue *  value  )

static

Definition at line 1868 of file xmlrpc.c.

References octstr_format(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, parse_value_element(), and XMLRPC_PARSING_FAILED.

Referenced by parse_data_element(), parse_fault_element(), parse_member_element(), and parse_param_element().

{
    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, xrdoc, value);
            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:
            xrdoc->parse_status = XMLRPC_PARSING_FAILED;
            xrdoc->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, xrdoc, value) == -1)
            return -1;

    return status;
}

parse_value_element()

static int parse_value_element ( xmlDocPtr  doc, xmlNodePtr  node, XMLRPCDocument *  xrdoc, XMLRPCValue *  xrvalue  )

static

Definition at line 1903 of file xmlrpc.c.

References dict_create(), error(), gwlist_create, name, NUMBER_OF_VALUE_ELEMENTS, octstr_case_compare(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), octstr_parse_double(), octstr_parse_long(), OPTIMAL_STRUCT_SIZE, parse_array(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, parse_struct(), xmlrpc_value::v_array, xmlrpc_value::v_scalar, xmlrpc_value::v_struct, xmlrpc_value::v_type, value_elements, XMLRPC_PARSING_FAILED, xmlrpc_scalar_create(), xmlrpc_value_destroy_item(), XMLRPC_XMLPARSE_FAILED, xr_array, xr_base64, xr_bool, xr_date, xr_double, xr_int, xr_scalar, xr_string, and xr_struct.

Referenced by parse_value().

{
    Octstr *name;
    Octstr *value = NULL;
    xmlChar *content_buff;
    long lval = 0;
    double dval = 0.0;
    size_t i;

    /*
     * check if the element is allowed at this level 
     */
    if (node->name == NULL) {
        error(0, "XMLRPC: XML value element nodes without name!");
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_format("XML-RPC compiler: bad XML");
        return -1;
    }

    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) {
        xrdoc->parse_status = XMLRPC_PARSING_FAILED;
        xrdoc->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);


    content_buff = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
    if (content_buff != NULL) {
        value = octstr_create(content_buff);
        xmlFree(content_buff);
    }

    /* 
     * 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:   case xr_bool:
        case xr_double:
        case xr_date:  case xr_base64:
#ifndef XR_ENABLE_EMPTY_STRING_VALUES
        case xr_string:
#endif
            if (value == NULL) {
                xrdoc->parse_status = XMLRPC_PARSING_FAILED;
                xrdoc->parse_error = octstr_format("XML-RPC compiler: no value for '%s'", 
                                           node->name);
                return -1;
            }
            break;
    }

    switch (value_elements[i].s_type) {
        
        /*
         * scalar types
         */
        case xr_int:
            if (value != NULL && octstr_parse_long(&lval, value, 0, 10) < 0) {
                xrdoc->parse_status = XMLRPC_PARSING_FAILED;
                xrdoc->parse_error = octstr_format("XML-RPC compiler: could not parse int value '%s'", 
                                                   octstr_get_cstr(value));
                octstr_destroy(value);
                return -1;
            }
            xrvalue->v_type = xr_scalar;
            xrvalue->v_scalar = xmlrpc_scalar_create(xr_int, (void *) &lval);
            break;
        
        case xr_bool:
            if (value != NULL && octstr_parse_long(&lval, value, 0, 10) < 0) {
                xrdoc->parse_status = XMLRPC_PARSING_FAILED;
                xrdoc->parse_error = octstr_format("XML-RPC compiler: could not parse boolean value '%s'", 
                                                   octstr_get_cstr(value));
                octstr_destroy(value);
                return -1;
            }
            xrvalue->v_type = xr_scalar;
            xrvalue->v_scalar = xmlrpc_scalar_create(xr_bool, (void *) &lval);
            break;

        case xr_double:
            if (value != NULL && octstr_parse_double(&dval, value, 0) < 0) {
                xrdoc->parse_status = XMLRPC_PARSING_FAILED;
                xrdoc->parse_error = octstr_format("XML-RPC compiler: could not parse double value '%s'", 
                                                   octstr_get_cstr(value));
                octstr_destroy(value);
                return -1;
            }
            xrvalue->v_type = xr_scalar;
            xrvalue->v_scalar = xmlrpc_scalar_create(xr_double, (void *) &dval);
            break;

        case xr_string:
            xrvalue->v_type = xr_scalar;
            xrvalue->v_scalar = xmlrpc_scalar_create(xr_string, (void *) value);
            break;

        case xr_date:
            xrvalue->v_type = xr_scalar;
            xrvalue->v_scalar = xmlrpc_scalar_create(xr_date, (void *) value);
            break;

        case xr_base64:
            xrvalue->v_type = xr_scalar;
            xrvalue->v_scalar = xmlrpc_scalar_create(xr_base64, (void *) value);
            break;

        case xr_struct:
            xrvalue->v_type = xr_struct;
            xrvalue->v_struct = dict_create(OPTIMAL_STRUCT_SIZE, xmlrpc_value_destroy_item);

            if (parse_struct(doc, node->xmlChildrenNode, xrdoc, xrvalue->v_struct) == -1) {
                octstr_destroy(value);
                return -1;
            }
            break;

        case xr_array:
            xrvalue->v_type = xr_array;
            xrvalue->v_array = gwlist_create();

            if (parse_array(doc, node->xmlChildrenNode, xrdoc, xrvalue->v_array) == -1) {
                xrdoc->parse_status = XMLRPC_PARSING_FAILED; 
                xrdoc->parse_error = octstr_format("XML-RPC compiler: could not parse array"); 
                octstr_destroy(value);
                return -1;
            }
            break;

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

    octstr_destroy(value);
    return 0;
}

xmlrpc_add_element()

int xmlrpc_add_element	(	XMLRPCValue *	xrarray,
		XMLRPCValue *	value
	)

Definition at line 1218 of file xmlrpc.c.

References gwlist_produce(), xmlrpc_value::v_array, xmlrpc_value::v_type, and xr_array.

Referenced by xmlrpc_add_element_scalar().

{
    if (xrarray == NULL || xrarray->v_type != xr_array || value == NULL)
        return -1;
    
    gwlist_produce(xrarray->v_array, value);
    return 1;
}

xmlrpc_add_element_scalar()

int xmlrpc_add_element_scalar	(	XMLRPCValue *	xrarray,
		int	type,
		void *	arg
	)

Definition at line 1227 of file xmlrpc.c.

References type, xmlrpc_add_element(), xmlrpc_create_scalar_value(), and xmlrpc_value_destroy().

{
    XMLRPCValue *value = xmlrpc_create_scalar_value(type, arg);
    int status;
    
    status = xmlrpc_add_element(xrarray, value);
    if (status < 0)
        xmlrpc_value_destroy(value);
        
    return status;
}

xmlrpc_add_member()

int xmlrpc_add_member	(	XMLRPCValue *	xrstruct,
		Octstr *	name,
		XMLRPCValue *	value
	)

Definition at line 1121 of file xmlrpc.c.

References dict_put_once(), name, xmlrpc_value::v_struct, xmlrpc_value::v_type, and xr_struct.

Referenced by xmlrpc_add_member_scalar().

{
    if (xrstruct == NULL || xrstruct->v_type != xr_struct 
        || name == NULL || value == NULL)
        return -1;
    
    return dict_put_once(xrstruct->v_struct, name, value);
}

xmlrpc_add_member_scalar()

int xmlrpc_add_member_scalar	(	XMLRPCValue *	xrstruct,
		Octstr *	name,
		int	type,
		void *	arg
	)

Definition at line 1130 of file xmlrpc.c.

References name, type, xmlrpc_add_member(), xmlrpc_create_scalar_value(), and xmlrpc_value_destroy().

{
    XMLRPCValue *value = xmlrpc_create_scalar_value(type, arg);
    int status;
    
    status = xmlrpc_add_member(xrstruct, name, value);
    if (status < 0)
        xmlrpc_value_destroy(value);
        
    return status;
}

xmlrpc_call_add_param()

static int xmlrpc_call_add_param ( XMLRPCMethodCall *  method, XMLRPCValue *  value  )

static

Definition at line 295 of file xmlrpc.c.

References gwlist_produce(), and method.

Referenced by xmlrpc_doc_add_value().

{
    if (method == NULL || value == NULL)
        return -1;

    gwlist_produce(method->params, value);
    return 0;
}

xmlrpc_call_create()

static XMLRPCMethodCall* xmlrpc_call_create ( Octstr *  name )

static

Definition at line 269 of file xmlrpc.c.

References gwlist_create, xmlrpc_methodcall::method_name, name, octstr_duplicate, and xmlrpc_methodcall::params.

Referenced by parse_document(), and xmlrpc_doc_create_call().

{
    XMLRPCMethodCall *nmsg = gw_malloc(sizeof(XMLRPCMethodCall));

    nmsg->method_name = octstr_duplicate(name);
    nmsg->params = gwlist_create();
    
    return nmsg;
}

xmlrpc_call_destroy()

static void xmlrpc_call_destroy ( XMLRPCMethodCall *  call )

static

Definition at line 279 of file xmlrpc.c.

References gwlist_destroy(), xmlrpc_methodcall::method_name, octstr_destroy(), xmlrpc_methodcall::params, and xmlrpc_value_destroy_item().

Referenced by parse_document(), and xmlrpc_doc_destroy().

{
    if (call == NULL)
        return;

    octstr_destroy(call->method_name);
    gwlist_destroy(call->params, xmlrpc_value_destroy_item);

    gw_free(call);
}

xmlrpc_call_get_name()

static Octstr* xmlrpc_call_get_name ( XMLRPCMethodCall *  call )

static

Definition at line 290 of file xmlrpc.c.

References xmlrpc_methodcall::method_name.

Referenced by xmlrpc_get_call_name().

{
    return call->method_name;
}

xmlrpc_call_print()

static Octstr* xmlrpc_call_print ( XMLRPCMethodCall *  call, int  level  )

static

Definition at line 304 of file xmlrpc.c.

References error(), gwlist_get(), gwlist_len(), gwlist_lock(), gwlist_unlock(), xmlrpc_methodcall::method_name, octstr_destroy(), octstr_format(), octstr_format_append(), xmlrpc_methodcall::params, and xmlrpc_value_print().

Referenced by xmlrpc_doc_print().

{
    Octstr *body, *os_value;
    XMLRPCValue *val;
    long i;

    if (call == NULL || call->method_name == NULL)
        return NULL;

    body = octstr_format("%*s<methodCall>\n"
                         "%*s<methodName>%S</methodName>\n",
                         level, "", level + 2, "", call->method_name);

    gwlist_lock(call->params);
    if (gwlist_len(call->params) > 0) {
        octstr_format_append(body, "%*s<params>\n", level + 2, "");
        for (i = 0; i < gwlist_len(call->params); i++) {
            val = gwlist_get(call->params, i);
            os_value = xmlrpc_value_print(val, level + 6);

            if (os_value == NULL) {
                error(0, "XMLRPC: Could not print method call, param %ld malformed", i);
                octstr_destroy(body);
                return NULL;
            }
            octstr_format_append(body, "%*s<param>\n%S%*s</param>\n", 
                                 level + 4, "", os_value, level + 4, "");
            octstr_destroy(os_value);
        }
        octstr_format_append(body, "%*s</params>\n", level + 2, "");
    }
    gwlist_unlock(call->params);
    octstr_format_append(body, "%*s</methodCall>\n", level, "");

    return body;
}

xmlrpc_count_elements()

int xmlrpc_count_elements

(

XMLRPCValue *

xrarray

)

Definition at line 1210 of file xmlrpc.c.

References gwlist_len(), xmlrpc_value::v_array, xmlrpc_value::v_type, and xr_array.

{
    if (xrarray == NULL || xrarray->v_type != xr_array)
        return -1;
    
    return  gwlist_len(xrarray->v_array);
}

xmlrpc_count_members()

long xmlrpc_count_members

(

XMLRPCValue *

xrstruct

)

Definition at line 1114 of file xmlrpc.c.

References dict_key_count(), xmlrpc_value::v_struct, xmlrpc_value::v_type, and xr_struct.

Referenced by parse_fault_element().

{
    if (xrstruct == NULL || xrstruct->v_type != xr_struct)
        return -1;
    return dict_key_count(xrstruct->v_struct);
}

xmlrpc_count_params()

int xmlrpc_count_params

(

XMLRPCDocument *

xrdoc

)

Definition at line 1064 of file xmlrpc.c.

References xmlrpc_document::d_type, gwlist_len(), xmlrpc_document::methodcall, xmlrpc_document::methodresponse, xmlrpc_methodresponse::param, xmlrpc_methodcall::params, xr_methodcall, and xr_methodresponse.

{
    if (xrdoc == NULL)
        return -1;
    if (xrdoc->d_type == xr_methodcall && xrdoc->methodcall != NULL)
        return gwlist_len(xrdoc->methodcall->params);
    else if (xrdoc->d_type == xr_methodresponse && xrdoc->methodresponse != NULL)
        return (xrdoc->methodresponse->param != NULL ? 1 : 0);
    
    return -1;
}

xmlrpc_create_array_value()

XMLRPCValue* xmlrpc_create_array_value

(

void

)

Definition at line 1201 of file xmlrpc.c.

References gwlist_create, xmlrpc_value::v_array, xmlrpc_value::v_type, xmlrpc_value_create(), and xr_array.

{
    XMLRPCValue *value = xmlrpc_value_create();
    value->v_type = xr_array;
    value->v_array = gwlist_create();

    return value;
}

xmlrpc_create_double_value()

XMLRPCValue* xmlrpc_create_double_value

(

double

val

)

Definition at line 1300 of file xmlrpc.c.

References xmlrpc_create_scalar_value(), and xr_double.

{
    return xmlrpc_create_scalar_value(xr_double, &val);
}

xmlrpc_create_int_value()

XMLRPCValue* xmlrpc_create_int_value

(

long

val

)

Definition at line 1305 of file xmlrpc.c.

References xmlrpc_create_scalar_value(), and xr_int.

{
    return xmlrpc_create_scalar_value(xr_int, &val);
}

xmlrpc_create_scalar_value()

XMLRPCValue* xmlrpc_create_scalar_value	(	int	type,
		void *	arg
	)

Definition at line 1291 of file xmlrpc.c.

References type, xmlrpc_value::v_scalar, xmlrpc_value::v_type, xmlrpc_scalar_create(), xmlrpc_value_create(), and xr_scalar.

Referenced by xmlrpc_add_element_scalar(), xmlrpc_add_member_scalar(), xmlrpc_create_double_value(), xmlrpc_create_int_value(), xmlrpc_create_string_value(), and xmlrpc_doc_add_scalar().

{
    XMLRPCValue *value = xmlrpc_value_create();
    value->v_type = xr_scalar;
    value->v_scalar = xmlrpc_scalar_create(type, arg);

    return value;
}

xmlrpc_create_string_value()

XMLRPCValue* xmlrpc_create_string_value

(

Octstr *

val

)

Definition at line 1310 of file xmlrpc.c.

References xmlrpc_create_scalar_value(), and xr_string.

{
    return xmlrpc_create_scalar_value(xr_string, val);
}

xmlrpc_create_struct_value()

XMLRPCValue* xmlrpc_create_struct_value

(

int

count_members

)

Definition at line 1104 of file xmlrpc.c.

References dict_create(), OPTIMAL_STRUCT_SIZE, xmlrpc_value::v_struct, xmlrpc_value::v_type, xmlrpc_value_create(), xmlrpc_value_destroy_item(), and xr_struct.

{
    XMLRPCValue *value = xmlrpc_value_create();
    int len = (count_members > 0 ? count_members : OPTIMAL_STRUCT_SIZE);
    value->v_type = xr_struct;
    value->v_struct = dict_create(len, xmlrpc_value_destroy_item);

    return value;
}

xmlrpc_doc_add_scalar()

int xmlrpc_doc_add_scalar	(	XMLRPCDocument *	xrdoc,
		int	d_type,
		int	type,
		void *	arg
	)

Definition at line 639 of file xmlrpc.c.

References type, xmlrpc_create_scalar_value(), xmlrpc_doc_add_value(), and xmlrpc_value_destroy().

{
    XMLRPCValue *param;
    
    param = xmlrpc_create_scalar_value(type, arg);
    if (xmlrpc_doc_add_value(xrdoc, d_type, param) < 0) {
        xmlrpc_value_destroy(param);
        return -1;
    }
    return 0;
}

xmlrpc_doc_add_value()

int xmlrpc_doc_add_value	(	XMLRPCDocument *	xrdoc,
		int	d_type,
		XMLRPCValue *	value
	)

Definition at line 612 of file xmlrpc.c.

References xmlrpc_document::d_type, error(), xmlrpc_document::methodcall, xmlrpc_document::methodresponse, xmlrpc_call_add_param(), xmlrpc_response_add_param(), xr_methodcall, xr_methodresponse, and xr_undefined.

Referenced by xmlrpc_doc_add_scalar().

{
    if (xrdoc == NULL) 
        return -1;

    if (xrdoc->d_type != d_type && d_type != xr_undefined) {
        error(0, "Wrong xmlrpc document type. Param not added.");
        return -1;
    }
    if (xrdoc->d_type == xr_methodresponse) {
        if (xmlrpc_response_add_param(xrdoc->methodresponse, value) < 0) 
            return -1;
    } 
    else if (xrdoc->d_type == xr_methodcall) {
        if (xmlrpc_call_add_param(xrdoc->methodcall, value) < 0) 
            return -1;
    }
    else {
        error(0, "Unknown xmlrpc document type. Param not added.");
        return -1;
    }
    return 0;
}

xmlrpc_doc_create()

XMLRPCDocument* xmlrpc_doc_create

(

void

)

Definition at line 513 of file xmlrpc.c.

References xmlrpc_document::d_type, xmlrpc_document::methodcall, xmlrpc_document::methodresponse, xmlrpc_document::parse_error, xmlrpc_document::parse_status, XMLRPC_COMPILE_OK, and xr_undefined.

Referenced by xmlrpc_doc_create_call(), xmlrpc_doc_create_response(), and xmlrpc_doc_parse().

{
    XMLRPCDocument *xrdoc = gw_malloc(sizeof(XMLRPCDocument));
    
    xrdoc->d_type = xr_undefined;
    xrdoc->parse_status = XMLRPC_COMPILE_OK;
    xrdoc->parse_error = NULL;
    xrdoc->methodcall = NULL;
    xrdoc->methodresponse = NULL;
    
    return xrdoc;
}

xmlrpc_doc_create_call()

XMLRPCDocument* xmlrpc_doc_create_call

(

Octstr *

name

)

Definition at line 526 of file xmlrpc.c.

References xmlrpc_document::d_type, xmlrpc_document::methodcall, name, xmlrpc_call_create(), xmlrpc_doc_create(), and xr_methodcall.

{
    XMLRPCDocument *xrdoc;
    
    xrdoc = xmlrpc_doc_create();
    xrdoc->d_type = xr_methodcall;
    xrdoc->methodcall = xmlrpc_call_create(name);
    
    return xrdoc;
}

xmlrpc_doc_create_faultresponse()

XMLRPCDocument* xmlrpc_doc_create_faultresponse	(	long	faultcode,
		Octstr *	faultstring
	)

Definition at line 548 of file xmlrpc.c.

References xmlrpc_document::methodresponse, response(), xmlrpc_doc_create_response(), and xmlrpc_fault_create().

{
    XMLRPCDocument *xrdoc;
    XMLRPCMethodResponse *response;
    
    xrdoc = xmlrpc_doc_create_response();

    response = xrdoc->methodresponse;
    response->fault = xmlrpc_fault_create(faultcode, faultstring);

    return xrdoc;
}

xmlrpc_doc_create_response()

XMLRPCDocument* xmlrpc_doc_create_response

(

void

)

Definition at line 537 of file xmlrpc.c.

References xmlrpc_document::d_type, xmlrpc_document::methodresponse, xmlrpc_doc_create(), xmlrpc_response_create(), and xr_methodresponse.

Referenced by xmlrpc_doc_create_faultresponse().

{
    XMLRPCDocument *xrdoc;
    
    xrdoc = xmlrpc_doc_create();
    xrdoc->d_type = xr_methodresponse;
    xrdoc->methodresponse = xmlrpc_response_create();
    
    return xrdoc;
}

xmlrpc_doc_destroy()

void xmlrpc_doc_destroy	(	XMLRPCDocument *	xrdoc,
		int	d_type
	)

Definition at line 594 of file xmlrpc.c.

References xmlrpc_document::d_type, xmlrpc_document::methodcall, xmlrpc_document::methodresponse, octstr_destroy(), xmlrpc_document::parse_error, warning(), xmlrpc_call_destroy(), and xmlrpc_response_destroy().

{
    if (xrdoc == NULL) 
        return;
    
    if (xrdoc->d_type != d_type)
        warning(0, "Destroying document with different type then given.");
    
    xmlrpc_call_destroy(xrdoc->methodcall);
    xmlrpc_response_destroy(xrdoc->methodresponse);
    octstr_destroy(xrdoc->parse_error);
    
    gw_free(xrdoc);
}

xmlrpc_doc_parse()

XMLRPCDocument* xmlrpc_doc_parse	(	Octstr *	post_body,
		int	d_type
	)

Definition at line 561 of file xmlrpc.c.

References xmlrpc_document::d_type, octstr_create, octstr_get_cstr, octstr_len(), octstr_shrink_blanks(), octstr_strip_blanks(), parse_document(), xmlrpc_document::parse_error, xmlrpc_document::parse_status, size, xmlrpc_doc_create(), and XMLRPC_XMLPARSE_FAILED.

{
    XMLRPCDocument *xrdoc = xmlrpc_doc_create();
    xmlDocPtr pDoc;
    size_t size;
    char *body;

    if (post_body == NULL) {
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_create("XMLRPC: (null) XML document given.");
        return xrdoc;
    }    
    xrdoc->d_type = d_type;
    
    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);
    if (!pDoc) {
        xrdoc->parse_status = XMLRPC_XMLPARSE_FAILED;
        xrdoc->parse_error = octstr_create("XMLRPC: not valid XML document given.");
        return xrdoc;
    }
    parse_document(pDoc, xrdoc);
    xmlFreeDoc(pDoc);
    
    return xrdoc;
}

xmlrpc_doc_print()

Octstr* xmlrpc_doc_print	(	XMLRPCDocument *	xrdoc,
		int	d_type,
		int	level
	)

Definition at line 654 of file xmlrpc.c.

References xmlrpc_document::d_type, error(), xmlrpc_document::methodcall, xmlrpc_document::methodresponse, octstr_destroy(), octstr_format(), octstr_insert(), xmlrpc_call_print(), xmlrpc_response_print(), xr_methodcall, and xr_methodresponse.

Referenced by xmlrpc_doc_send().

{
    Octstr *body = NULL, *pref = NULL;

    if (xrdoc == NULL) 
        return NULL;

    if (xrdoc->d_type != d_type) {
        error(0, "Wrong xmlrpc document type.");
        return NULL;
    }
    if (xrdoc->d_type == xr_methodresponse) {
        body = xmlrpc_response_print(xrdoc->methodresponse, level);
    } 
    else if (xrdoc->d_type == xr_methodcall) {
        body = xmlrpc_call_print(xrdoc->methodcall, level);
    }
    else {
        error(0, "Unknown xmlrpc document type.");
    }

    if (body != NULL) {
        pref = octstr_format("%*s<?xml version=\"1.0\"?>\n", level, "");
        octstr_insert(body, pref, 0);
        octstr_destroy(pref);
    }
    return body;
}

xmlrpc_doc_send()

int xmlrpc_doc_send	(	XMLRPCDocument *	xrdoc,
		int	d_type,
		HTTPCaller *	http_ref,
		Octstr *	url,
		List *	headers,
		void *	ref
	)

Definition at line 686 of file xmlrpc.c.

References xmlrpc_document::d_type, error(), gwlist_create, http_header_add(), http_header_remove_all(), HTTP_METHOD_POST, http_start_request(), octstr_destroy(), url, and xmlrpc_doc_print().

{
    Octstr *body;
    if (http_ref == NULL || xrdoc == NULL)
        return -1;
    
    if (xrdoc->d_type != d_type) {
        error(0, "Wrong xmlrpc document type.");
        return -1;
    }
    
    if (headers == NULL)
        headers = gwlist_create();
    
    http_header_remove_all(headers, "Content-Type");
    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_doc_print(xrdoc, d_type, 0);

    http_start_request(http_ref, HTTP_METHOD_POST, 
                       url, headers, body, 0, ref, NULL);
    
    octstr_destroy(body);
    /* XXX: should headers be destroyed here? */
    /*http_destroy_headers(headers); */
    return 0;
}

xmlrpc_fault_create()

static XMLRPCFault* xmlrpc_fault_create ( long  fcode, Octstr *  fstring  )

static

Definition at line 346 of file xmlrpc.c.

References xmlrpc_fault::f_code, xmlrpc_fault::f_string, and octstr_duplicate.

Referenced by parse_methodresponse_element(), and xmlrpc_doc_create_faultresponse().

{
    XMLRPCFault *fault = gw_malloc(sizeof(XMLRPCFault));
    
    fault->f_code = fcode;
    fault->f_string = octstr_duplicate(fstring);
    
    return fault;
}

xmlrpc_fault_destroy()

static void xmlrpc_fault_destroy ( XMLRPCFault *  fault )

static

Definition at line 356 of file xmlrpc.c.

References xmlrpc_fault::f_string, and octstr_destroy().

Referenced by xmlrpc_response_destroy().

{
    if (fault == NULL) return;
    
    octstr_destroy(fault->f_string);
    gw_free(fault);
}

xmlrpc_fault_get_code()

static long xmlrpc_fault_get_code ( XMLRPCFault *  fault )

static

Definition at line 364 of file xmlrpc.c.

References xmlrpc_fault::f_code.

Referenced by xmlrpc_response_get_faultcode().

{
    if (fault == NULL) return -1;
    
    return fault->f_code;
}

xmlrpc_fault_get_string()

static Octstr* xmlrpc_fault_get_string ( XMLRPCFault *  fault )

static

Definition at line 371 of file xmlrpc.c.

References xmlrpc_fault::f_string.

Referenced by xmlrpc_response_get_faultstring().

{
    if (fault == NULL) return NULL;
    
    return fault->f_string;
}

xmlrpc_fault_print()

static Octstr* xmlrpc_fault_print ( XMLRPCFault *  fault, int  level  )

static

Definition at line 378 of file xmlrpc.c.

References xmlrpc_fault::f_code, xmlrpc_fault::f_string, octstr_format(), and octstr_imm().

Referenced by xmlrpc_response_print().

{
    Octstr *os;
    
    if (fault == NULL) return NULL;
    
    os = octstr_format("%*s<fault>\n%*s<value>\n"
                         "%*s<struct>\n"
                           "%*s<member>\n"
                             "%*s<name>faultCode</name>\n"
                             "%*s<value><int>%ld</int></value>\n"
                           "%*s</member>\n"
                           "%*s<member>\n"
                             "%*s<name>faultString</name>\n"
                             "%*s<value><string>%S</string></value>\n"
                           "%*s</member>\n"
                           "%*s</struct>\n"
                       "%*s</value>\n%*s</fault>\n",
                       level, "", level+2, "", level+4, "", level+6, "", 
                       level+8, "", level+8, "",
                       fault->f_code,
                       level+6, "", level+6, "", level+8, "", level+8, "",
                       (fault->f_string == NULL ? octstr_imm("/") : fault->f_string),
                       level+6, "", level+4, "", level+2, "", level, "");

    return os;
}

xmlrpc_get_call_name()

Octstr* xmlrpc_get_call_name

(

XMLRPCDocument *

call

)

Definition at line 1056 of file xmlrpc.c.

References xmlrpc_document::methodcall, and xmlrpc_call_get_name().

Referenced by smsbox_xmlrpc_post().

{
    if (call == NULL || call->methodcall == NULL)
        return NULL;
    return xmlrpc_call_get_name(call->methodcall);
}

xmlrpc_get_content_param()

void* xmlrpc_get_content_param	(	XMLRPCDocument *	xrdoc,
		int	i
	)

Definition at line 1096 of file xmlrpc.c.

References xmlrpc_get_param(), and xmlrpc_value_get_content().

{
    XMLRPCValue *param = xmlrpc_get_param(xrdoc, i);
    
    return xmlrpc_value_get_content(param);
}

xmlrpc_get_element()

XMLRPCValue* xmlrpc_get_element	(	XMLRPCValue *	xrarray,
		int	i
	)

Definition at line 1239 of file xmlrpc.c.

References gwlist_get(), xmlrpc_value::v_array, xmlrpc_value::v_type, and xr_array.

Referenced by xmlrpc_get_element_content(), and xmlrpc_get_element_type().

{
    if (xrarray == NULL || xrarray->v_type != xr_array || i < 0)
        return NULL;
    
    return gwlist_get(xrarray->v_array, i);
}

xmlrpc_get_element_content()

void* xmlrpc_get_element_content	(	XMLRPCValue *	xrarray,
		int	i
	)

Definition at line 1254 of file xmlrpc.c.

References xmlrpc_get_element(), and xmlrpc_value_get_content().

{
    XMLRPCValue *value = xmlrpc_get_element(xrarray, i);
    
    return xmlrpc_value_get_content(value);
}

xmlrpc_get_element_type()

int xmlrpc_get_element_type	(	XMLRPCValue *	xrarray,
		int	i
	)

Definition at line 1247 of file xmlrpc.c.

References xmlrpc_get_element(), and xmlrpc_value_get_type().

{
    XMLRPCValue *value = xmlrpc_get_element(xrarray, i);
    
    return xmlrpc_value_get_type(value);
}

xmlrpc_get_faultcode()

long xmlrpc_get_faultcode

(

XMLRPCDocument *

faultresponse

)

Definition at line 1325 of file xmlrpc.c.

References error(), xmlrpc_document::methodresponse, xmlrpc_is_fault(), and xmlrpc_response_get_faultcode().

Referenced by receive_reply().

{
    if (! xmlrpc_is_fault(faultresponse)) {
        error(0, "XMLRPC object is not fault response.");
        return -1;
    }
    
    return xmlrpc_response_get_faultcode(faultresponse->methodresponse);
}

xmlrpc_get_faultstring()

Octstr* xmlrpc_get_faultstring

(

XMLRPCDocument *

faultresponse

)

Definition at line 1335 of file xmlrpc.c.

References error(), xmlrpc_document::methodresponse, xmlrpc_is_fault(), and xmlrpc_response_get_faultstring().

Referenced by receive_reply().

{
    if (! xmlrpc_is_fault(faultresponse)) {
        error(0, "XMLRPC object is not fault response.");
        return NULL;
    }
    
    return xmlrpc_response_get_faultstring(faultresponse->methodresponse);
}

xmlrpc_get_member()

XMLRPCValue* xmlrpc_get_member	(	XMLRPCValue *	xrstruct,
		Octstr *	name
	)

Definition at line 1142 of file xmlrpc.c.

References dict_get(), name, xmlrpc_value::v_struct, xmlrpc_value::v_type, and xr_struct.

Referenced by parse_fault_element(), xmlrpc_get_member_content(), and xmlrpc_get_member_type().

{
    if (xrstruct == NULL || xrstruct->v_type != xr_struct || name == NULL)
        return NULL;
    
    return dict_get(xrstruct->v_struct, name);
}

xmlrpc_get_member_content()

void* xmlrpc_get_member_content	(	XMLRPCValue *	xrstruct,
		Octstr *	name
	)

Definition at line 1157 of file xmlrpc.c.

References name, xmlrpc_get_member(), and xmlrpc_value_get_content().

{
    XMLRPCValue *value = xmlrpc_get_member(xrstruct, name);
    
    return xmlrpc_value_get_content(value);
}

xmlrpc_get_member_type()

int xmlrpc_get_member_type	(	XMLRPCValue *	xrstruct,
		Octstr *	name
	)

Definition at line 1150 of file xmlrpc.c.

References name, xmlrpc_get_member(), and xmlrpc_value_get_type().

{
    XMLRPCValue *value = xmlrpc_get_member(xrstruct, name);
    
    return xmlrpc_value_get_type(value);
}

xmlrpc_get_param()

XMLRPCValue* xmlrpc_get_param	(	XMLRPCDocument *	xrdoc,
		int	i
	)

Definition at line 1076 of file xmlrpc.c.

References xmlrpc_document::d_type, gwlist_get(), gwlist_len(), xmlrpc_document::methodcall, xmlrpc_document::methodresponse, xmlrpc_methodresponse::param, xmlrpc_methodcall::params, xr_methodcall, and xr_methodresponse.

Referenced by xmlrpc_get_content_param(), and xmlrpc_get_type_param().

{
    if (xrdoc == NULL)
        return NULL;
    if (xrdoc->d_type == xr_methodcall && xrdoc->methodcall != NULL) 
        return gwlist_len(xrdoc->methodcall->params) > i ? gwlist_get(xrdoc->methodcall->params, i) : NULL;
    else if (xrdoc->d_type == xr_methodresponse && xrdoc->methodresponse != NULL
             && i == 0)
        return xrdoc->methodresponse->param;
    
    return NULL;
}

xmlrpc_get_type_param()

int xmlrpc_get_type_param	(	XMLRPCDocument *	xrdoc,
		int	i
	)

Definition at line 1089 of file xmlrpc.c.

References xmlrpc_get_param(), and xmlrpc_value_get_type().

{
    XMLRPCValue *param = xmlrpc_get_param(xrdoc, i);
    
    return xmlrpc_value_get_type(param);
}

xmlrpc_is_fault()

int xmlrpc_is_fault

(

XMLRPCDocument *

response

)

Definition at line 1317 of file xmlrpc.c.

References response(), xmlrpc_response_is_fault(), and xr_methodresponse.

Referenced by receive_reply(), xmlrpc_get_faultcode(), and xmlrpc_get_faultstring().

{
    if (response == NULL || response->d_type != xr_methodresponse)
        return 0;
    
    return xmlrpc_response_is_fault(response->methodresponse);
}

xmlrpc_member_create()

static XMLRPCMember* xmlrpc_member_create ( void  )

static

Definition at line 1027 of file xmlrpc.c.

References xmlrpc_member::name, and xmlrpc_member::value.

Referenced by parse_struct_element().

{
    XMLRPCMember *member = gw_malloc(sizeof(XMLRPCMember));

    member->name = NULL;
    member->value = NULL;

    return member;
}

xmlrpc_member_destroy()

static void xmlrpc_member_destroy ( XMLRPCMember *  member, int  destroy_value  )

static

Definition at line 1038 of file xmlrpc.c.

References xmlrpc_member::name, octstr_destroy(), xmlrpc_member::value, and xmlrpc_value_destroy().

Referenced by parse_struct_element().

{
    if (member == NULL)
        return;

    octstr_destroy(member->name);
    if (destroy_value == 1)
        xmlrpc_value_destroy(member->value);

    gw_free(member);
}

xmlrpc_parse_error()

Octstr* xmlrpc_parse_error

(

XMLRPCDocument *

xrdoc

)

Definition at line 1356 of file xmlrpc.c.

References octstr_duplicate, and xmlrpc_document::parse_error.

Referenced by main(), receive_reply(), and smsbox_xmlrpc_post().

{
    if (xrdoc == NULL)
        return NULL;
    
    return octstr_duplicate(xrdoc->parse_error);
}

xmlrpc_parse_status()

int xmlrpc_parse_status

(

XMLRPCDocument *

xrdoc

)

Definition at line 1348 of file xmlrpc.c.

References xmlrpc_document::parse_status.

Referenced by main(), receive_reply(), and smsbox_xmlrpc_post().

{
    if (xrdoc == NULL)
        return -1;

    return xrdoc->parse_status;
}

xmlrpc_print_array()

Octstr* xmlrpc_print_array	(	List *	v_array,
		int	level
	)

Definition at line 1261 of file xmlrpc.c.

References gwlist_get(), gwlist_len(), octstr_append(), octstr_destroy(), octstr_format(), octstr_format_append(), and xmlrpc_value_print().

Referenced by xmlrpc_value_print().

{
    Octstr *body, *os_element;
    XMLRPCValue *element = NULL;
    int i;
    
    if (v_array == NULL)
        return NULL;
    
    body = octstr_format("%*s<array>\n%*s<data>\n", level, "", level+2, "");

    for(i = 0; i < gwlist_len(v_array); i++) {
        element = gwlist_get(v_array, i);
        os_element = xmlrpc_value_print(element, level+4);
        if (os_element == NULL) {
            octstr_destroy(body);
            return NULL;
        }
        
        octstr_append(body, os_element);
        octstr_destroy(os_element);
    }
    octstr_format_append(body, "%*s</data>\n%*s</array>\n", 
                         level+2, "", level, "");
    
    return body;
}

xmlrpc_print_struct()

Octstr* xmlrpc_print_struct	(	Dict *	v_struct,
		int	level
	)

Definition at line 1164 of file xmlrpc.c.

References dict_get(), dict_key_count(), dict_keys(), gwlist_consume(), gwlist_destroy(), octstr_destroy(), octstr_destroy_item(), octstr_format(), octstr_format_append(), and xmlrpc_value_print().

Referenced by xmlrpc_value_print().

{
    Octstr *body, *os_val, *key;
    List *keys;
    XMLRPCValue *member_val;

    if (v_struct == NULL || dict_key_count(v_struct) == 0)
        return NULL;
    
    keys = dict_keys(v_struct);
    body = octstr_format("%*s<struct>\n", level, "");

    while ((key = gwlist_consume(keys)) != NULL) {
        member_val = dict_get(v_struct, key);
        os_val = xmlrpc_value_print(member_val, level+4);
        if (os_val == NULL) {
            gwlist_destroy(keys, octstr_destroy_item);
            octstr_destroy(key);
            octstr_destroy(body);
            return NULL;
        }
        octstr_format_append(body, "%*s<member>\n"
                                     "%*s<name>%S</name>\n%S"
                                   "%*s</member>\n",
                                   level+2, "", level+4, "",
                                   key, os_val,
                                   level+2, "");
        octstr_destroy(key);
        octstr_destroy(os_val);
    }
    gwlist_destroy(keys, octstr_destroy_item);
    octstr_format_append(body, "%*s</struct>\n", level, "");
    
    return body;
}

xmlrpc_response_add_param()

static int xmlrpc_response_add_param ( XMLRPCMethodResponse *  response, XMLRPCValue *  value  )

static

Definition at line 433 of file xmlrpc.c.

References error(), and response().

Referenced by xmlrpc_doc_add_value().

{
    if (response == NULL || value == NULL)
        return -1;

    if (response->param != NULL) {
        error(0, "XMLRPC: Method Response may contain only one param.");
        return -1;
    }
    if (response->fault != NULL) {
        error(0, "XMLRPC: Fault Response may not contain any param.");
        return -1;
    }
    
    response->param = value;
    return 0;
}

xmlrpc_response_create()

static XMLRPCMethodResponse* xmlrpc_response_create ( void  )

static

Definition at line 412 of file xmlrpc.c.

References xmlrpc_methodresponse::fault, and xmlrpc_methodresponse::param.

Referenced by parse_document(), and xmlrpc_doc_create_response().

{
    XMLRPCMethodResponse *nmsg = gw_malloc(sizeof(XMLRPCMethodResponse));

    nmsg->param = NULL;
    nmsg->fault = NULL;
    
    return nmsg;
}

xmlrpc_response_destroy()

static void xmlrpc_response_destroy ( XMLRPCMethodResponse *  response )

static

Definition at line 422 of file xmlrpc.c.

References response(), xmlrpc_fault_destroy(), and xmlrpc_value_destroy().

Referenced by parse_document(), and xmlrpc_doc_destroy().

{
    if (response == NULL)
        return;

    xmlrpc_value_destroy(response->param);
    xmlrpc_fault_destroy(response->fault);

    gw_free(response);
}

xmlrpc_response_get_faultcode()

static long xmlrpc_response_get_faultcode ( XMLRPCMethodResponse *  faultresponse )

static

Definition at line 459 of file xmlrpc.c.

References error(), xmlrpc_methodresponse::fault, xmlrpc_fault_get_code(), and xmlrpc_response_is_fault().

Referenced by xmlrpc_get_faultcode().

{
    if (! xmlrpc_response_is_fault(faultresponse)) {
        error(0, "XMLRPC response is not fault response.");
        return -1;
    }
    
    return xmlrpc_fault_get_code(faultresponse->fault);
}

xmlrpc_response_get_faultstring()

static Octstr* xmlrpc_response_get_faultstring ( XMLRPCMethodResponse *  faultresponse )

static

Definition at line 469 of file xmlrpc.c.

References error(), xmlrpc_methodresponse::fault, xmlrpc_fault_get_string(), and xmlrpc_response_is_fault().

Referenced by xmlrpc_get_faultstring().

{
    if (! xmlrpc_response_is_fault(faultresponse)) {
        error(0, "XMLRPC response is not fault response.");
        return NULL;
    }
    
    return xmlrpc_fault_get_string(faultresponse->fault);
}

xmlrpc_response_is_fault()

static int xmlrpc_response_is_fault ( XMLRPCMethodResponse *  response )

static

Definition at line 451 of file xmlrpc.c.

References response().

Referenced by xmlrpc_is_fault(), xmlrpc_response_get_faultcode(), and xmlrpc_response_get_faultstring().

{
    if (response == NULL || response->fault == NULL)
        return 0;
    
    return 1;
}

xmlrpc_response_print()

static Octstr* xmlrpc_response_print ( XMLRPCMethodResponse *  response, int  level  )

static

Definition at line 480 of file xmlrpc.c.

References octstr_destroy(), octstr_format(), response(), xmlrpc_fault_print(), and xmlrpc_value_print().

Referenced by xmlrpc_doc_print().

{
    Octstr *body = NULL, *os_value = NULL;

    if (response->fault == NULL && response->param != NULL) {
        os_value = xmlrpc_value_print(response->param, level + 6);

        body = octstr_format("%*s<methodResponse>\n"
                             "%*s<params>\n%*s<param>\n"
                             "%S"
                             "%*s</param>\n%*s</params>\n"
                             "%*s</methodResponse>\n",
                             level, "", level+2, "", level+4, "", os_value, 
                             level+4, "", level+2, "", level, "");
    } 
    else if (response->fault != NULL && response->param == NULL) {
        os_value = xmlrpc_fault_print(response->fault, level + 2);

        body = octstr_format("%*s<methodResponse>\n"
                             "%S"
                             "%*s</methodResponse>\n",
                             level, "", os_value, level, "");
    }
    
    octstr_destroy(os_value);
    return body;
}

xmlrpc_scalar_create()

XMLRPCScalar* xmlrpc_scalar_create	(	int	type,
		void *	arg
	)

Definition at line 880 of file xmlrpc.c.

References error(), octstr_duplicate, xmlrpc_scalar::s_base64, xmlrpc_scalar::s_bool, xmlrpc_scalar::s_date, xmlrpc_scalar::s_double, xmlrpc_scalar::s_int, xmlrpc_scalar::s_str, xmlrpc_scalar::s_type, type, xmlrpc_scalar_destroy(), xr_base64, xr_bool, xr_date, xr_double, xr_int, and xr_string.

Referenced by parse_value_element(), and xmlrpc_create_scalar_value().

{
    XMLRPCScalar *scalar = gw_malloc(sizeof(XMLRPCScalar));

    scalar->s_type = type;
    scalar->s_int = 0;
    scalar->s_bool = 0;
    scalar->s_double = 0.0;
    scalar->s_str = NULL;
    scalar->s_date = NULL;
    scalar->s_base64 = NULL;
    
    if (arg == NULL) {
#ifdef XR_ENABLE_EMPTY_STRING_VALUES
        if (scalar->s_type != xr_string) {
#endif
            error(0,"XML-RPC: scalar value may not be null!");
            xmlrpc_scalar_destroy(scalar);
            return NULL;
#ifdef XR_ENABLE_EMPTY_STRING_VALUES
        }
#endif
    }
    switch (type) {
        case xr_int:
            if (arg != NULL) 
                scalar->s_int = *(long*)arg;
            break;
        case xr_bool:
            if (arg != NULL) 
                scalar->s_bool = *(int*)arg;
            break;
        case xr_double:
            if (arg != NULL) 
                scalar->s_double = *(double*)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:
            error(0,"XML-RPC: scalar type not supported!");
            xmlrpc_scalar_destroy(scalar);
            return NULL;
    }
    return scalar;
}

xmlrpc_scalar_destroy()

void xmlrpc_scalar_destroy

(

XMLRPCScalar *

scalar

)

Definition at line 935 of file xmlrpc.c.

References octstr_destroy(), xmlrpc_scalar::s_base64, xmlrpc_scalar::s_date, and xmlrpc_scalar::s_str.

Referenced by xmlrpc_scalar_create(), and xmlrpc_value_destroy().

{
    if (scalar == NULL)
        return;

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

xmlrpc_scalar_get_content()

void* xmlrpc_scalar_get_content	(	XMLRPCScalar *	scalar,
		int	s_type
	)

Definition at line 954 of file xmlrpc.c.

References error(), xmlrpc_scalar::s_base64, xmlrpc_scalar::s_bool, xmlrpc_scalar::s_date, xmlrpc_scalar::s_double, xmlrpc_scalar::s_int, xmlrpc_scalar::s_str, xmlrpc_scalar::s_type, xr_base64, xr_bool, xr_date, xr_double, xr_int, and xr_string.

{
    if (scalar == NULL)
        return NULL;
    if (scalar->s_type != s_type) {
        error(0, "XMLRPC: Scalar content request with bogus type");
        return NULL;
    }
    switch (scalar->s_type) {
        case xr_int:     return &(scalar->s_int);
        case xr_bool:    return &(scalar->s_bool);
        case xr_double:  return &(scalar->s_double);
        case xr_string:  return scalar->s_str;
        case xr_date:    return scalar->s_date;
        case xr_base64:  return scalar->s_base64;
        default:
            error(0,"XML-RPC: scalar type not supported!");
            return NULL;
    }
}

xmlrpc_scalar_get_type()

int xmlrpc_scalar_get_type

(

XMLRPCScalar *

scalar

)

Definition at line 947 of file xmlrpc.c.

References xmlrpc_scalar::s_type.

{
    if (scalar == NULL)
        return -1;
    return scalar->s_type;
}

xmlrpc_scalar_print()

Octstr* xmlrpc_scalar_print	(	XMLRPCScalar *	scalar,
		int	level
	)

Definition at line 975 of file xmlrpc.c.

References octstr_convert_to_html_entities(), octstr_destroy(), octstr_duplicate, octstr_format(), xmlrpc_scalar::s_base64, xmlrpc_scalar::s_bool, xmlrpc_scalar::s_date, xmlrpc_scalar::s_double, xmlrpc_scalar::s_int, xmlrpc_scalar::s_str, xmlrpc_scalar::s_type, xr_base64, xr_bool, xr_date, xr_double, xr_int, and xr_string.

Referenced by xmlrpc_value_print().

{
    Octstr *os = NULL;
    
    if (scalar == NULL)
        return NULL;

    switch (scalar->s_type) {
        case xr_int:
            os = octstr_format("%*s<int>%ld</int>\n", 
                               level, "", scalar->s_int);
            break;
        case xr_bool:
            os = octstr_format("%*s<bool>%d</bool>\n", 
                               level, "", scalar->s_bool);
            break;
        case xr_double:
            os = octstr_format("%*s<double>%d</double>\n", 
                                 level, "", scalar->s_double);
            break;
        case xr_string:
            if (scalar->s_str == NULL) {
#ifdef XR_ENABLE_EMPTY_STRING_VALUES
                os = octstr_format("%*s<string></string>\n", 
                                   level, "");
#endif
            } else {
                Octstr *tmp = octstr_duplicate(scalar->s_str);
                octstr_convert_to_html_entities(tmp);
                os = octstr_format("%*s<string>%S</string>\n", 
                                   level, "", tmp);
                octstr_destroy(tmp);
            }
            break;
        case xr_date:
            os = octstr_format("%*s<datetime.iso8601>%S</datetime.iso8601>\n", 
                               level, "", scalar->s_date);
            break;
        case xr_base64:
            os = octstr_format("%*s<base64>%S</base64>\n", 
                               level, "", scalar->s_base64);
            break;
    }
    return os;    
}

xmlrpc_value_create()

XMLRPCValue* xmlrpc_value_create

(

void

)

Definition at line 729 of file xmlrpc.c.

References xmlrpc_value::v_array, xmlrpc_value::v_scalar, xmlrpc_value::v_struct, xmlrpc_value::v_type, and xr_undefined.

Referenced by parse_data_element(), parse_fault_element(), parse_member_element(), parse_param_element(), xmlrpc_create_array_value(), xmlrpc_create_scalar_value(), and xmlrpc_create_struct_value().

{
    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;
}

xmlrpc_value_destroy()

void xmlrpc_value_destroy

(

XMLRPCValue *

val

)

Definition at line 741 of file xmlrpc.c.

References dict_destroy(), gwlist_destroy(), xmlrpc_value::v_array, xmlrpc_value::v_scalar, xmlrpc_value::v_struct, xmlrpc_value::v_type, xmlrpc_scalar_destroy(), xmlrpc_value_destroy_item(), xr_array, xr_scalar, and xr_struct.

Referenced by parse_data_element(), parse_fault_element(), parse_member_element(), parse_param_element(), xmlrpc_add_element_scalar(), xmlrpc_add_member_scalar(), xmlrpc_doc_add_scalar(), xmlrpc_member_destroy(), xmlrpc_response_destroy(), and xmlrpc_value_destroy_item().

{
    if (val == NULL)
        return;

    switch(val->v_type) {
        case xr_scalar:
            xmlrpc_scalar_destroy(val->v_scalar);
            break;
        case xr_array:
            gwlist_destroy(val->v_array, xmlrpc_value_destroy_item);
            break;
        case xr_struct:
            dict_destroy(val->v_struct);
            break;
    }
    gw_free(val);
}

xmlrpc_value_destroy_item()

void xmlrpc_value_destroy_item

(

void *

val

)

Definition at line 761 of file xmlrpc.c.

References xmlrpc_value_destroy().

Referenced by parse_methodresponse_element(), parse_value_element(), xmlrpc_call_destroy(), xmlrpc_create_struct_value(), and xmlrpc_value_destroy().

{
    xmlrpc_value_destroy(val);
}

xmlrpc_value_get_content()

void* xmlrpc_value_get_content

(

XMLRPCValue *

val

)

Definition at line 825 of file xmlrpc.c.

References error(), xmlrpc_value::v_array, xmlrpc_value::v_scalar, xmlrpc_value::v_struct, xmlrpc_value::v_type, xr_array, xr_scalar, and xr_struct.

Referenced by parse_fault_element(), xmlrpc_get_content_param(), xmlrpc_get_element_content(), and xmlrpc_get_member_content().

{
    if (val == NULL)
        return NULL;
        
    switch(val->v_type) {
        case xr_scalar:
            return val->v_scalar;
        case xr_array:
            return val->v_array;
        case xr_struct:
            return val->v_struct;
        default:
            error(0, "XMLRPC: value type not supported.");
            return NULL;
    }
}

xmlrpc_value_get_type()

int xmlrpc_value_get_type

(

XMLRPCValue *

val

)

Definition at line 808 of file xmlrpc.c.

References xmlrpc_value::v_type.

Referenced by parse_fault_element(), xmlrpc_get_element_type(), xmlrpc_get_member_type(), xmlrpc_get_type_param(), and xmlrpc_value_get_type_smart().

{
    if (val == NULL)
        return -1;
        
    return val->v_type;
}

xmlrpc_value_get_type_smart()

int xmlrpc_value_get_type_smart

(

XMLRPCValue *

val

)

Definition at line 816 of file xmlrpc.c.

References type, xmlrpc_get_scalar_value_type, xmlrpc_value_get_type(), and xr_scalar.

Referenced by parse_fault_element().

{
    int type = xmlrpc_value_get_type(val);
    if (type == xr_scalar) 
        return xmlrpc_get_scalar_value_type(val);

    return type;
}

xmlrpc_value_print()

Octstr* xmlrpc_value_print	(	XMLRPCValue *	val,
		int	level
	)

Definition at line 843 of file xmlrpc.c.

References octstr_destroy(), octstr_format(), xmlrpc_value::v_array, xmlrpc_value::v_scalar, xmlrpc_value::v_struct, xmlrpc_value::v_type, xmlrpc_print_array(), xmlrpc_print_struct(), xmlrpc_scalar_print(), xr_array, xr_scalar, and xr_struct.

Referenced by xmlrpc_call_print(), xmlrpc_print_array(), xmlrpc_print_struct(), and xmlrpc_response_print().

{
    Octstr *body = NULL, *os = NULL;

    if (val == NULL)
        return NULL;
    
    switch(val->v_type) {
        case xr_scalar:
            os = xmlrpc_scalar_print(val->v_scalar, level+2);
           break;
        case xr_struct:
            os = xmlrpc_print_struct(val->v_struct, level+2);
            break;
        case xr_array:
            os = xmlrpc_print_array(val->v_array, level+2);
            break;
        default:
            return NULL;
    }

    if (os != NULL) {
        body = octstr_format("%*s<value>\n%S%*s</value>\n",
                             level, "", os, level, "");
        octstr_destroy(os);
    }
    
    return body;
}

xmlrpc_value_set_content()

int xmlrpc_value_set_content	(	XMLRPCValue *	val,
		void *	content
	)

Definition at line 785 of file xmlrpc.c.

References error(), xmlrpc_value::v_array, xmlrpc_value::v_scalar, xmlrpc_value::v_struct, xmlrpc_value::v_type, xr_array, xr_scalar, and xr_struct.

{
    if (val == NULL)
        return -1;

    switch(val->v_type) {
        case xr_scalar:
            val->v_scalar = (XMLRPCScalar *)content;
            break;
        case xr_array:
            val->v_array  = (List *)content;
            break;
        case xr_struct:
            val->v_struct = (Dict *)content;
            break;
        default:
            error(0, "XMLRPC: value type not supported.");
            return -1;
    }
    
    return 0;
}

xmlrpc_value_set_type()

int xmlrpc_value_set_type	(	XMLRPCValue *	val,
		int	v_type
	)

Definition at line 766 of file xmlrpc.c.

References error(), xmlrpc_value::v_type, xr_array, xr_scalar, and xr_struct.

{
    if (val == NULL)
        return -1;

    switch(v_type) {
        case xr_scalar:
        case xr_array:
        case xr_struct:
            val->v_type = v_type;
            break;
        default:
            error(0, "XMLRPC: value type not supported.");
            return -1;
    }
    
    return 0;
}

Variable Documentation

array_elements

xmlrpc_table_t array_elements[]

static

Initial value:

= {
    { "DATA" }
}

Definition at line 183 of file xmlrpc.c.

Referenced by parse_array_element().

data_elements

xmlrpc_table_t data_elements[]

static

Initial value:

= {
    { "VALUE" }
}

Definition at line 187 of file xmlrpc.c.

Referenced by parse_data_element().

fault_elements

xmlrpc_table_t fault_elements[]

static

Initial value:

= {
    { "VALUE" }
}

Definition at line 191 of file xmlrpc.c.

Referenced by parse_fault_element().

member_elements

xmlrpc_table_t member_elements[]

static

Initial value:

= {
    { "NAME" },
    { "VALUE" }
}

Definition at line 178 of file xmlrpc.c.

Referenced by parse_member_element().

methodcall_elements

xmlrpc_table_t methodcall_elements[]

static

Initial value:

= {
    { "METHODNAME" },
    { "PARAMS" }
}

Definition at line 144 of file xmlrpc.c.

Referenced by parse_methodcall_element().

methodresponse_elements

xmlrpc_table_t methodresponse_elements[]

static

Initial value:

= {
    { "FAULT" },
    { "PARAMS" }
}

Definition at line 149 of file xmlrpc.c.

Referenced by parse_methodresponse_element().

param_elements

xmlrpc_table_t param_elements[]

static

Initial value:

= {
    { "VALUE" }
}

Definition at line 158 of file xmlrpc.c.

Referenced by parse_param_element().

params_elements

xmlrpc_table_t params_elements[]

static

Initial value:

= {
    { "PARAM" }
}

Definition at line 154 of file xmlrpc.c.

Referenced by parse_params_element().

struct_elements

xmlrpc_table_t struct_elements[]

static

Initial value:

= {
    { "MEMBER" }
}

Definition at line 174 of file xmlrpc.c.

Referenced by parse_struct_element().

value_elements

xmlrpc_2table_t value_elements[]

static

Initial value:

= {
    { "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 }
}

Definition at line 162 of file xmlrpc.c.

Referenced by parse_value_element().