break;    }    return scalar;}XMLRPCScalar *xmlrpc_scalar_create_double(int type, double val){    XMLRPCScalar *scalar = gw_malloc(sizeof(XMLRPCScalar));    scalar->s_type = type;    scalar->s_int = 0;    scalar->s_bool = 0;    scalar->s_double = 0;    scalar->s_str = NULL;    scalar->s_date = NULL;    scalar->s_base64 = NULL;        switch (type) {        case xr_double:            scalar->s_double = val;            break;        default:            panic(0,"XML-RPC: scalar type not supported!");            break;    }    return scalar;}/* Destroy scalar */void xmlrpc_scalar_destroy(XMLRPCScalar *scalar){    if (scalar == NULL)	return;    octstr_destroy(scalar->s_str);    octstr_destroy(scalar->s_date);    octstr_destroy(scalar->s_base64);        gw_free(scalar);}void xmlrpc_scalar_print(XMLRPCScalar *scalar, Octstr *os){    switch (scalar->s_type) {        case xr_int:            octstr_format_append(os, "<int>%d</int>", scalar->s_int);            break;        case xr_bool:            octstr_format_append(os, "<bool>%d</bool>", scalar->s_bool);            break;        case xr_string:            octstr_format_append(os, "<string>%S</string>", scalar->s_str);            break;        case xr_double:            octstr_format_append(os, "<double>%d</double>", scalar->s_double);            break;        case xr_date:            octstr_format_append(os, "<date>%S</date>", scalar->s_date);            break;        case xr_base64:            octstr_format_append(os, "<base64>%S</base64>", scalar->s_base64);            break;    }}/*------------------------------------------------- * Utilities to make things easier *//* create scalar value from given arguments * XXX: Should this take different kind of arguments? */XMLRPCValue *xmlrpc_create_scalar_value(int type, void *arg){    XMLRPCValue *value = xmlrpc_value_create();    value->v_type = xr_scalar;    value->v_scalar = xmlrpc_scalar_create(type, arg);    return value;}XMLRPCValue *xmlrpc_create_scalar_value_double(int type, double val){    XMLRPCValue *value = xmlrpc_value_create();    value->v_type = xr_scalar;    value->v_scalar = xmlrpc_scalar_create_double(type, val);    return value;}XMLRPCValue *xmlrpc_create_struct_value(int type, void *arg){    XMLRPCValue *value = xmlrpc_value_create();    value->v_type = xr_struct;    value->v_struct = list_create();    return value;}int xmlrpc_parse_status(XMLRPCMethodCall *call){    if (call == NULL)	   return -1;    return call->parse_status;}Octstr *xmlrpc_parse_error(XMLRPCMethodCall *call) {    if (call == NULL)        return NULL;        return call->parse_error;}Octstr *xmlrpc_get_method_name(XMLRPCMethodCall *call){    if (call == NULL)        return NULL;    return call->method_name;}int xmlrpc_call_len(XMLRPCMethodCall *call){    if (call == NULL)        return 0;    return list_len(call->params);}int xmlrpc_get_type(XMLRPCMethodCall *call, int pos){    XMLRPCValue *var;    if (call == NULL)        return -1;    var = list_get(call->params, pos);    return var->v_type;}/*------------------------------------------------- * Internal parser functions */static int parse_member_element(xmlDocPtr doc, xmlNodePtr node,                                 XMLRPCMethodCall **msg){    Octstr *name;    size_t i;    /*     * check if the element is allowed at this level      */    name = octstr_create(node->name);    if (octstr_len(name) == 0) {        octstr_destroy(name);        return -1;    }    i = 0;    while (i < NUMBER_OF_MEMBER_ELEMENTS) {        if (octstr_case_compare(name, octstr_imm(member_elements[i].name)) == 0)            break;        ++i;    }    if (i == NUMBER_OF_MEMBER_ELEMENTS) {        (*msg)->parse_status = XMLRPC_PARSING_FAILED;        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "                                            "in XML source at level <member>",                                             octstr_get_cstr(name));        octstr_destroy(name);        return -1;    }     octstr_destroy(name);    /*      * now check which type it is and process      *     * valid tags at this level are:     *   name [0]     *   value [1]     */    if (i == 0) {        /* this has been a <member> tag */        //if (parse_name(doc, node->xmlChildrenNode, msg) == -1)        //    return -1;    } else {        /* we should never be here */        (*msg)->parse_status = XMLRPC_PARSING_FAILED;        (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_member!");        return -1;    }    return 0;}static int parse_member(xmlDocPtr doc, xmlNodePtr node,                         XMLRPCMethodCall **msg){    int status = 0;      /* call for the parser function of the node type. */    switch (node->type) {        case XML_ELEMENT_NODE:            status = parse_member_element(doc, node, msg);            break;        case XML_TEXT_NODE:        case XML_COMMENT_NODE:        case XML_PI_NODE:            /* Text nodes, comments and PIs are ignored. */            break;	   /*	    * XML has also many other node types, these are not needed with 	    * XML-RPC. Therefore they are assumed to be an error.	    */        default:            (*msg)->parse_status = XMLRPC_PARSING_FAILED;            (*msg)->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");            return -1;            break;    }    if (node->next != NULL)	   if (parse_member(doc, node->next, msg) == -1)            return -1;    return status;}static int parse_struct_element(xmlDocPtr doc, xmlNodePtr node,                                 XMLRPCMethodCall **msg){    Octstr *name;    size_t i;    /*     * check if the element is allowed at this level      */    name = octstr_create(node->name);    if (octstr_len(name) == 0) {        octstr_destroy(name);        return -1;    }    i = 0;    while (i < NUMBER_OF_STRUCT_ELEMENTS) {        if (octstr_case_compare(name, octstr_imm(struct_elements[i].name)) == 0)            break;        ++i;    }    if (i == NUMBER_OF_STRUCT_ELEMENTS) {        (*msg)->parse_status = XMLRPC_PARSING_FAILED;        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "                                            "in XML source at level <struct>",                                             octstr_get_cstr(name));        octstr_destroy(name);        return -1;    }     octstr_destroy(name);    /*      * now check which type it is and process      *     * valid tags at this level are:     *   member [0]     */    if (i == 0) {        /* this has been a <member> tag */        if (parse_member(doc, node->xmlChildrenNode, msg) == -1)            return -1;    } else {        /* we should never be here */        (*msg)->parse_status = XMLRPC_PARSING_FAILED;        (*msg)->parse_error = octstr_format("XML-RPC compiler: bogus parsing exception in parse_struct!");        return -1;    }    return 0;}static int parse_struct(xmlDocPtr doc, xmlNodePtr node,                         XMLRPCMethodCall **msg){    int status = 0;      /* call for the parser function of the node type. */    switch (node->type) {        case XML_ELEMENT_NODE:            status = parse_struct_element(doc, node, msg);            break;        case XML_TEXT_NODE:        case XML_COMMENT_NODE:        case XML_PI_NODE:            /* Text nodes, comments and PIs are ignored. */            break;	   /*	    * XML has also many other node types, these are not needed with 	    * XML-RPC. Therefore they are assumed to be an error.	    */        default:            (*msg)->parse_status = XMLRPC_PARSING_FAILED;            (*msg)->parse_error = octstr_format("XML-RPC compiler: Unknown XML node in the XML-RPC source.");            return -1;            break;    }    if (node->next != NULL)	   if (parse_struct(doc, node->next, msg) == -1)            return -1;    return status;}static int parse_value_element(xmlDocPtr doc, xmlNodePtr node,                                XMLRPCMethodCall **msg){    Octstr *name;    Octstr *value;    long lval = 0;    size_t i;    /*     * check if the element is allowed at this level      */    name = octstr_create(node->name);    if (octstr_len(name) == 0) {        octstr_destroy(name);        return -1;    }    i = 0;    while (i < NUMBER_OF_VALUE_ELEMENTS) {        if (octstr_case_compare(name, octstr_imm(value_elements[i].name)) == 0)            break;        ++i;    }    if (i == NUMBER_OF_VALUE_ELEMENTS) {        (*msg)->parse_status = XMLRPC_PARSING_FAILED;        (*msg)->parse_error = octstr_format("XML-RPC compiler: unknown tag '%s' "                                            "in XML source at level <value>",                                             octstr_get_cstr(name));        octstr_destroy(name);        return -1;    }     octstr_destroy(name);    value = octstr_create(xmlNodeListGetString(doc, node->xmlChildrenNode, 1));    if (value == NULL) {        (*msg)->parse_status = XMLRPC_PARSING_FAILED;        (*msg)->parse_error = octstr_format("XML-RPC compiler: no value for '%s'",                                             node->name);        return -1;    }    /*      * now check which type it is and process      *     * valid tags at this level are:     *   i4, int     *   boolean     *   string     *   double     *   dateTime.iso8601     *   base64     *   struct     *   array     */    switch (value_elements[i].s_type) {                /*         * scalar types         */        case xr_int:            if (octstr_parse_long(&lval, value, 0, 10) < 0) {                (*msg)->parse_status = XMLRPC_PARSING_FAILED;                (*msg)->parse_error = octstr_format("XML-RPC compiler: could not parse int value '%s'",                                                     octstr_get_cstr(value));                return -1;            }            //xmlrpc_call_add_int((*msg), lval);            xmlrpc_call_add_scalar((*msg), xr_int, (void *) lval);            debug("", 0, "XML-RPC: added int %ld", lval);            break;                case xr_bool:            if (octstr_parse_long(&lval, value, 0, 10) < 0) {                (*msg)->parse_status = XMLRPC_PARSING_FAILED;