diff options
Diffstat (limited to 'ext/rpc/xmlrpc/xmlrpc-epi-php.c')
| -rw-r--r-- | ext/rpc/xmlrpc/xmlrpc-epi-php.c | 1421 |
1 files changed, 1421 insertions, 0 deletions
diff --git a/ext/rpc/xmlrpc/xmlrpc-epi-php.c b/ext/rpc/xmlrpc/xmlrpc-epi-php.c new file mode 100644 index 0000000000..589adaad05 --- /dev/null +++ b/ext/rpc/xmlrpc/xmlrpc-epi-php.c @@ -0,0 +1,1421 @@ +/* + This file is part of, or distributed with, libXMLRPC - a C library for + xml-encoded function calls. + + Author: Dan Libby (dan@libby.com) + Epinions.com may be contacted at feedback@epinions-inc.com +*/ + +/* + Copyright 2001 Epinions, Inc. + + Subject to the following 3 conditions, Epinions, Inc. permits you, free + of charge, to (a) use, copy, distribute, modify, perform and display this + software and associated documentation files (the "Software"), and (b) + permit others to whom the Software is furnished to do so as well. + + 1) The above copyright notice and this permission notice shall be included + without modification in all copies or substantial portions of the + Software. + + 2) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT ANY WARRANTY OR CONDITION OF + ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION ANY + IMPLIED WARRANTIES OF ACCURACY, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE OR NONINFRINGEMENT. + + 3) IN NO EVENT SHALL EPINIONS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT, + SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT + OF OR IN CONNECTION WITH THE SOFTWARE (HOWEVER ARISING, INCLUDING + NEGLIGENCE), EVEN IF EPINIONS, INC. IS AWARE OF THE POSSIBILITY OF SUCH + DAMAGES. + +*/ + +/* auto-generated portions of this file are also subject to the php license */ + +/* + +----------------------------------------------------------------------+ + | PHP version 4.0 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.02 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available at through the world-wide-web at | + | http://www.php.net/license/2_02.txt. | + | If you did not receive a copy of the PHP license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@php.net so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: | + | | + +----------------------------------------------------------------------+ + */ + +#include "php.h" +#include "php_ini.h" +#include "php_xmlrpc.h" +#include "xmlrpc.h" + +/* You should tweak config.m4 so this symbol (or some else suitable) + gets defined. +*/ + +#ifdef ZTS +int xmlrpc_globals_id; +#else +php_xmlrpc_globals xmlrpc_globals; +#endif + + +/* Every user visible function must have an entry in xmlrpc_functions[]. +*/ +function_entry xmlrpc_functions[] = { + PHP_FE(xmlrpc_encode, NULL) + PHP_FE(xmlrpc_decode, NULL) + PHP_FE(xmlrpc_decode_request, NULL) + PHP_FE(xmlrpc_encode_request, NULL) + PHP_FE(xmlrpc_get_type, NULL) + PHP_FE(xmlrpc_set_type, NULL) + PHP_FE(xmlrpc_server_create, NULL) + PHP_FE(xmlrpc_server_destroy, NULL) + PHP_FE(xmlrpc_server_register_method, NULL) + PHP_FE(xmlrpc_server_call_method, NULL) + PHP_FE(xmlrpc_parse_method_descriptions, NULL) + PHP_FE(xmlrpc_server_add_introspection_data, NULL) + PHP_FE(xmlrpc_server_register_introspection_callback, NULL) + {NULL, NULL, NULL} /* Must be the last line in xmlrpc_functions[] */ +}; + +zend_module_entry xmlrpc_module_entry = { + "xmlrpc", + xmlrpc_functions, + PHP_MINIT(xmlrpc), + PHP_MSHUTDOWN(xmlrpc), + PHP_RINIT(xmlrpc), /* Replace with NULL if there's nothing to do at request start */ + PHP_RSHUTDOWN(xmlrpc), /* Replace with NULL if there's nothing to do at request end */ + PHP_MINFO(xmlrpc), + STANDARD_MODULE_PROPERTIES +}; + +#ifdef COMPILE_DL_XMLRPC +ZEND_GET_MODULE(xmlrpc) +#endif + +/* Remove comments and fill if you need to have entries in php.ini +PHP_INI_BEGIN() +PHP_INI_END() +*/ + +/******************************* +* local structures and defines * +*******************************/ + +// per server data +typedef struct _xmlrpc_server_data { + pval* method_map; + pval* introspection_map; + XMLRPC_SERVER server_ptr; +} xmlrpc_server_data; + + +// how to format output +typedef struct _php_output_options { + int b_php_out; + STRUCT_XMLRPC_REQUEST_OUTPUT_OPTIONS xmlrpc_out; +} php_output_options; + +// data passed to C callback +typedef struct _xmlrpc_callback_data { + pval* xmlrpc_method; + pval* php_function; + pval* caller_params; + pval* return_data; + xmlrpc_server_data* server; + char php_executed; +} xmlrpc_callback_data; + +#define PHP_EXT_VERSION "0.41" + +// output options +#define OUTPUT_TYPE_KEY "output_type" +#define OUTPUT_TYPE_KEY_LEN (sizeof(OUTPUT_TYPE_KEY) - 1) +#define OUTPUT_TYPE_VALUE_PHP "php" +#define OUTPUT_TYPE_VALUE_XML "xml" + +#define VERBOSITY_KEY "verbosity" +#define VERBOSITY_KEY_LEN (sizeof(VERBOSITY_KEY) - 1) +#define VERBOSITY_VALUE_NO_WHITE_SPACE "no_white_space" +#define VERBOSITY_VALUE_NEWLINES_ONLY "newlines_only" +#define VERBOSITY_VALUE_PRETTY "pretty" + +#define ESCAPING_KEY "escaping" +#define ESCAPING_KEY_LEN (sizeof(ESCAPING_KEY) - 1) +#define ESCAPING_VALUE_CDATA "cdata" +#define ESCAPING_VALUE_NON_ASCII "non-ascii" +#define ESCAPING_VALUE_NON_PRINT "non-print" +#define ESCAPING_VALUE_MARKUP "markup" + +#define VERSION_KEY "version" +#define VERSION_KEY_LEN (sizeof(VERSION_KEY) - 1) +#define VERSION_VALUE_SIMPLE "simple" +#define VERSION_VALUE_XMLRPC "xmlrpc" + +#define ENCODING_KEY "encoding" +#define ENCODING_KEY_LEN (sizeof(ENCODING_KEY) - 1) +#define ENCODING_DEFAULT "iso-8859-1" + +// value types +#define OBJECT_TYPE_ATTR "xmlrpc_type" +#define OBJECT_VALUE_ATTR "scalar" + + + +/*********************** +* forward declarations * +***********************/ +XMLRPC_VALUE_TYPE get_pval_xmlrpc_type(pval* value, pval** newvalue); +static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data); + +/********************* +* startup / shutdown * +*********************/ + +static void destroy_server_data(xmlrpc_server_data *server) { + if(server) { + XMLRPC_ServerDestroy(server->server_ptr); + + zval_dtor(server->method_map); + FREE_ZVAL(server->method_map); + + zval_dtor(server->introspection_map); + FREE_ZVAL(server->introspection_map); + + efree(server); + } +} + +/* called when server is being destructed. either when xmlrpc_server_destroy + * is called, or when request ends. + */ +static void xmlrpc_server_destructor(zend_rsrc_list_entry *rsrc) { + if(rsrc && rsrc->ptr) { + destroy_server_data((xmlrpc_server_data*)rsrc->ptr); + } +} + +/* module init */ +PHP_MINIT_FUNCTION(xmlrpc) +{ +/* Remove comments if you have entries in php.ini + REGISTER_INI_ENTRIES(); +*/ + XMLRPCG(le_xmlrpc_server) = zend_register_list_destructors_ex(xmlrpc_server_destructor, NULL, "xmlrpc server", module_number); + + return SUCCESS; +} + +/* module shutdown */ +PHP_MSHUTDOWN_FUNCTION(xmlrpc) +{ +/* Remove comments if you have entries in php.ini + UNREGISTER_INI_ENTRIES(); +*/ + return SUCCESS; +} + +/* Remove if there's nothing to do at request start */ +PHP_RINIT_FUNCTION(xmlrpc) +{ + return SUCCESS; +} + +/* Remove if there's nothing to do at request end */ +PHP_RSHUTDOWN_FUNCTION(xmlrpc) +{ + return SUCCESS; +} + +/* display info in phpinfo() */ +PHP_MINFO_FUNCTION(xmlrpc) +{ + php_info_print_table_start(); + php_info_print_table_row(2, "core library version", XMLRPC_GetVersionString()); + php_info_print_table_row(2, "php extension version", PHP_EXT_VERSION); + php_info_print_table_row(2, "author", "Dan Libby"); + php_info_print_table_row(2, "homepage", "http://xmlrpc-epi.sourceforge.net"); + php_info_print_table_row(2, "open sourced by", "Epinions.com"); + php_info_print_table_end(); + + /* + DISPLAY_INI_ENTRIES(); + */ +} + +/******************* +* random utilities * +*******************/ + +/* Utility functions for adding data types to arrays, with or without key (assoc, non-assoc). + * Could easily be further generalized to work with objects. + */ +static int add_long(pval* list, char* id, int num) { + if(id) return add_assoc_long(list, id, num); + else return add_next_index_long(list, num); +} + +static int add_double(pval* list, char* id, double num) { + if(id) return add_assoc_double(list, id, num); + else return add_next_index_double(list, num); +} + +static int add_string(pval* list, char* id, char* string, int duplicate) { + if(id) return add_assoc_string(list, id, string, duplicate); + else return add_next_index_string(list, string, duplicate); +} + +static int add_stringl(pval* list, char* id, char* string, uint length, int duplicate) { + if(id) return add_assoc_stringl(list, id, string, length, duplicate); + else return add_next_index_stringl(list, string, length, duplicate); +} + +static int add_pval(pval* list, const char* id, pval** val) { + if(list && val) { + if(id) return zend_hash_update(list->value.ht, (char*)id, strlen(id)+1, (void *) val, sizeof(pval **), NULL); + else return zend_hash_next_index_insert(list->value.ht, (void *) val, sizeof(pval **), NULL); + } +} + +#if ZEND_MODULE_API_NO >= 20001222 +#define my_zend_hash_get_current_key(ht, my_key, num_index) zend_hash_get_current_key(ht, my_key, num_index, 0) +#else +#define my_zend_hash_get_current_key(ht, my_key, num_index) zend_hash_get_current_key(ht, my_key, num_index) +#endif + + +/************************* +* input / output options * +*************************/ + +/* parse an array (user input) into output options suitable for use by xmlrpc engine + * and determine whether to return data as xml or php vars + */ +static void set_output_options(php_output_options* options, pval* output_opts) { + + if(options) { + + /* defaults */ + options->b_php_out = 0; + options->xmlrpc_out.version = xmlrpc_version_1_0; + options->xmlrpc_out.xml_elem_opts.encoding = ENCODING_DEFAULT; + options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_pretty; + options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping | xml_elem_non_ascii_escaping | xml_elem_non_print_escaping; + + if(output_opts && output_opts->type == IS_ARRAY) { + pval** val; + + /* verbosity of generated xml */ + if(zend_hash_find(output_opts->value.ht, + OUTPUT_TYPE_KEY, OUTPUT_TYPE_KEY_LEN + 1, + (void**)&val) == SUCCESS) { + if((*val)->type == IS_STRING) { + if(!strcmp((*val)->value.str.val, OUTPUT_TYPE_VALUE_PHP)) { + options->b_php_out = 1; + } + else if(!strcmp((*val)->value.str.val, OUTPUT_TYPE_VALUE_XML)) { + options->b_php_out = 0; + } + } + } + + /* verbosity of generated xml */ + if(zend_hash_find(output_opts->value.ht, + VERBOSITY_KEY, VERBOSITY_KEY_LEN + 1, + (void**)&val) == SUCCESS) { + if((*val)->type == IS_STRING) { + if(!strcmp((*val)->value.str.val, VERBOSITY_VALUE_NO_WHITE_SPACE)) { + options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_no_white_space; + } + else if(!strcmp((*val)->value.str.val, VERBOSITY_VALUE_NEWLINES_ONLY)) { + options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_newlines_only; + } + else if(!strcmp((*val)->value.str.val, VERBOSITY_VALUE_PRETTY)) { + options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_pretty; + } + } + } + + /* version of xml to output */ + if(zend_hash_find(output_opts->value.ht, + VERSION_KEY, VERSION_KEY_LEN + 1, + (void**)&val) == SUCCESS) { + if((*val)->type == IS_STRING) { + if(!strcmp((*val)->value.str.val, VERSION_VALUE_XMLRPC)) { + options->xmlrpc_out.version = xmlrpc_version_1_0; + } + else if(!strcmp((*val)->value.str.val, VERSION_VALUE_SIMPLE)) { + options->xmlrpc_out.version = xmlrpc_version_simple; + } + } + } + + /* encoding code set */ + if(zend_hash_find(output_opts->value.ht, + ENCODING_KEY, ENCODING_KEY_LEN + 1, + (void**)&val) == SUCCESS) { + if((*val)->type == IS_STRING) { + options->xmlrpc_out.xml_elem_opts.encoding = estrdup((*val)->value.str.val); + } + } + + /* escaping options */ + if(zend_hash_find(output_opts->value.ht, + ESCAPING_KEY, ESCAPING_KEY_LEN + 1, + (void**)&val) == SUCCESS) { + /* multiple values allowed. check if array */ + if((*val)->type == IS_ARRAY) { + pval** iter_val; + zend_hash_internal_pointer_reset((*val)->value.ht); + options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_no_escaping; + while(1) { + if(zend_hash_get_current_data((*val)->value.ht, (void**)&iter_val) == SUCCESS) { + if((*iter_val)->type == IS_STRING && (*iter_val)->value.str.val) { + if(!strcmp((*iter_val)->value.str.val, ESCAPING_VALUE_CDATA)) { + options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_cdata_escaping; + } + else if(!strcmp((*iter_val)->value.str.val, ESCAPING_VALUE_NON_ASCII)) { + options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_ascii_escaping; + } + else if(!strcmp((*iter_val)->value.str.val, ESCAPING_VALUE_NON_PRINT)) { + options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_print_escaping; + } + else if(!strcmp((*iter_val)->value.str.val, ESCAPING_VALUE_MARKUP)) { + options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_markup_escaping; + } + } + } + else { + break; + } + + zend_hash_move_forward((*val)->value.ht); + } + } + /* else, check for single value */ + else if((*val)->type == IS_STRING) { + if(!strcmp((*val)->value.str.val, ESCAPING_VALUE_CDATA)) { + options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_cdata_escaping; + } + else if(!strcmp((*val)->value.str.val, ESCAPING_VALUE_NON_ASCII)) { + options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_ascii_escaping; + } + else if(!strcmp((*val)->value.str.val, ESCAPING_VALUE_NON_PRINT)) { + options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_print_escaping; + } + else if(!strcmp((*val)->value.str.val, ESCAPING_VALUE_MARKUP)) { + options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping; + } + } + } + } + } +} + + +/****************** +* encode / decode * +******************/ + +/* php arrays have no distinction between array and struct types. + * they even allow mixed. Thus, we determine the type by iterating + * through the entire array and figuring out each element. + * room for some optimation here if we stop after a specific # of elements. + */ +static XMLRPC_VECTOR_TYPE determine_vector_type(HashTable *ht) { + int bArray = 0, bStruct = 0, bMixed = 0; + unsigned long num_index; + char* my_key; + + zend_hash_internal_pointer_reset(ht); + while(1) { + int res = my_zend_hash_get_current_key(ht, &my_key, &num_index); + if(res == HASH_KEY_IS_LONG) { + if(bStruct) { + bMixed = 1; + break; + } + bArray = 1; + } + else if(res == HASH_KEY_NON_EXISTANT) { + break; + } + else if(res == HASH_KEY_IS_STRING) { + if(bArray) { + bMixed = 1; + break; + } + bStruct = 1; + } + + zend_hash_move_forward(ht); + } + return bMixed ? xmlrpc_vector_mixed : (bStruct ? xmlrpc_vector_struct : xmlrpc_vector_array); +} + +/* recursively convert php values into xmlrpc values */ +static XMLRPC_VALUE PHP_to_XMLRPC_worker(const char* key, pval* in_val, int depth) { + XMLRPC_VALUE xReturn = NULL; + if(in_val) { + pval* val = NULL; + XMLRPC_VALUE_TYPE type = get_pval_xmlrpc_type(in_val, &val); + if(val) { + switch(type) { + case xmlrpc_base64: + if(val->type == IS_NULL) { + xReturn = XMLRPC_CreateValueBase64(key, "", 1); + } + else { + xReturn = XMLRPC_CreateValueBase64(key, val->value.str.val, val->value.str.len); + } + break; + case xmlrpc_datetime: + convert_to_string(val); + xReturn = XMLRPC_CreateValueDateTime_ISO8601(key, val->value.str.val); + break; + case xmlrpc_boolean: + convert_to_boolean(val); + xReturn = XMLRPC_CreateValueBoolean(key, val->value.lval); + break; + case xmlrpc_int: + convert_to_long(val); + xReturn = XMLRPC_CreateValueInt(key, val->value.lval); + break; + case xmlrpc_double: + convert_to_double(val); + xReturn = XMLRPC_CreateValueDouble(key, val->value.dval); + break; + case xmlrpc_string: + convert_to_string(val); + xReturn = XMLRPC_CreateValueString(key, val->value.str.val, val->value.str.len); + break; + case xmlrpc_vector: + { + unsigned long num_index; + pval** pIter; + char* my_key; + + convert_to_array(val); + + xReturn = XMLRPC_CreateVector(key, determine_vector_type(val->value.ht)); + + zend_hash_internal_pointer_reset(val->value.ht); + while(1) { + int res = my_zend_hash_get_current_key(val->value.ht, &my_key, &num_index); + if(res == HASH_KEY_IS_LONG) { + if(zend_hash_get_current_data(val->value.ht, (void**)&pIter) == SUCCESS) { + XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(0, *pIter, depth++)); + } + } + else if(res == HASH_KEY_NON_EXISTANT) { + break; + } + else if(res == HASH_KEY_IS_STRING) { + if(zend_hash_get_current_data(val->value.ht, (void**)&pIter) == SUCCESS) { + XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(my_key, *pIter, depth++)); + } + } + + zend_hash_move_forward(val->value.ht); + } + } + break; + default: + break; + } + } + } + return xReturn; +} + +static XMLRPC_VALUE PHP_to_XMLRPC(pval* root_val) { + return PHP_to_XMLRPC_worker(NULL, root_val, 0); +} + +/* recursively convert xmlrpc values into php values */ +static pval* XMLRPC_to_PHP(XMLRPC_VALUE el) { + pval* elem = NULL; + char* pBuf; + const char* pStr; + + if(el) { + XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(el); + + MAKE_STD_ZVAL(elem); /* init. very important. spent a frustrating day finding this out. */ + + switch(type) { + case xmlrpc_empty: + elem->type = IS_NULL; + break; + case xmlrpc_string: + pStr = XMLRPC_GetValueString(el); + if(pStr) { + elem->value.str.len = XMLRPC_GetValueStringLen(el); + elem->value.str.val = estrndup(pStr, elem->value.str.len); + elem->type = IS_STRING; + } + break; + case xmlrpc_int: + elem->value.lval = XMLRPC_GetValueInt(el); + elem->type = IS_LONG; + break; + case xmlrpc_boolean: + elem->value.lval = XMLRPC_GetValueBoolean(el); + elem->type = IS_BOOL; + break; + case xmlrpc_double: + elem->value.dval = XMLRPC_GetValueDouble(el); + elem->type = IS_DOUBLE; + break; + case xmlrpc_datetime: + elem->value.str.len = XMLRPC_GetValueStringLen(el); + elem->value.str.val = estrndup(XMLRPC_GetValueDateTime_ISO8601(el), elem->value.str.len); + elem->type = IS_STRING; + break; + case xmlrpc_base64: + pStr = XMLRPC_GetValueBase64(el); + if(pStr) { + elem->value.str.len = XMLRPC_GetValueStringLen(el); + elem->value.str.val = estrndup(pStr, elem->value.str.len); + elem->type = IS_STRING; + } + break; + case xmlrpc_vector: + if(array_init(elem) == SUCCESS) { + XMLRPC_VALUE xIter = XMLRPC_VectorRewind(el); + + while( xIter ) { + pval* val = XMLRPC_to_PHP(xIter); + if(val) { + add_pval(elem, XMLRPC_GetValueID(xIter), &val); + } + xIter = XMLRPC_VectorNext(el); + } + } + break; + default: + break; + } + set_pval_xmlrpc_type(elem, type); + } + return elem; +} + +/* {{{ proto string xmlrpc_encode_request(string method, mixed params) + generate xml for a method request */ +PHP_FUNCTION(xmlrpc_encode_request) { + XMLRPC_REQUEST xRequest = NULL; + pval* method, *vals, *out_opts; + char* outBuf; + php_output_options out; + + if( !(ARG_COUNT(ht) == 2 || ARG_COUNT(ht) == 3) || + getParameters(ht, ARG_COUNT(ht), &method, &vals, &out_opts) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + set_output_options(&out, (ARG_COUNT(ht) == 3) ? out_opts : 0); + + if(return_value_used) { + xRequest = XMLRPC_RequestNew(); + + if(xRequest) { + XMLRPC_RequestSetOutputOptions(xRequest, &out.xmlrpc_out); + if(method->type == IS_NULL) { + XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_response); + } + else { + XMLRPC_RequestSetMethodName(xRequest, method->value.str.val); + XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_call); + } + if(vals->type != IS_NULL) { + XMLRPC_RequestSetData(xRequest, PHP_to_XMLRPC(vals)); + } + + outBuf = XMLRPC_REQUEST_ToXML(xRequest, 0); + if(outBuf) { + RETVAL_STRING(outBuf, 1); + free(outBuf); + } + XMLRPC_RequestFree(xRequest, 1); + } + } +} + +/* {{{ proto string xmlrpc_encode(mixed value) + generate xml for a PHP value */ +PHP_FUNCTION(xmlrpc_encode) +{ + XMLRPC_VALUE xOut = NULL; + pval* arg1, *out_opts; + php_output_options out; + char* outBuf; + + if( !(ARG_COUNT(ht) == 1) || + getParameters(ht, ARG_COUNT(ht), &arg1) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + if( return_value_used ) { + /* convert native php type to xmlrpc type */ + xOut = PHP_to_XMLRPC(arg1); + + /* generate raw xml from xmlrpc data */ + outBuf = XMLRPC_VALUE_ToXML(xOut, 0); + + if(xOut) { + if(outBuf) { + RETVAL_STRING(outBuf, 1); + free(outBuf); + } + /* cleanup */ + XMLRPC_CleanupValue(xOut); + } + } +} + + +/* }}} */ + +pval* decode_request_worker(pval* xml_in, pval* encoding_in, pval* method_name_out) { + pval* retval = NULL; + XMLRPC_REQUEST response; + STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS opts = {0}; + opts.xml_elem_opts.encoding = encoding_in ? utf8_get_encoding_id_from_string(encoding_in->value.str.val) : ENCODING_DEFAULT; + + /* generate XMLRPC_REQUEST from raw xml */ + response = XMLRPC_REQUEST_FromXML(xml_in->value.str.val, xml_in->value.str.len, &opts); + if(response) { + /* convert xmlrpc data to native php types */ + retval = XMLRPC_to_PHP(XMLRPC_RequestGetData(response)); + + if(XMLRPC_RequestGetRequestType(response) == xmlrpc_request_call) { + if(method_name_out) { + convert_to_string(method_name_out); + method_name_out->type = IS_STRING; + method_name_out->value.str.val = estrdup(XMLRPC_RequestGetMethodName(response)); + method_name_out->value.str.len = strlen(method_name_out->value.str.val); + } + } + + /* dust, sweep, and mop */ + XMLRPC_RequestFree(response, 1); + } + return retval; +} + +/* {{{ proto array xmlrpc_decode_request(string xml, string& method, [string encoding]) + decode xml into native php types */ +PHP_FUNCTION(xmlrpc_decode_request) +{ + pval* xml, *method, *encoding = NULL; + + if( !(ARG_COUNT(ht) == 2 || ARG_COUNT(ht) == 3) || getParameters(ht, ARG_COUNT(ht), &xml, &method, &encoding) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } +#if ZEND_MODULE_API_NO < 20010901 + if (!ParameterPassedByReference(ht,2)) { + zend_error(E_WARNING,"second argument to xmlrpc_decode_request() passed by value, expecting reference"); + } +#endif + + convert_to_string(xml); + convert_to_string(method); + if(ARG_COUNT(ht) == 3) { + convert_to_string(encoding); + } + + if(return_value_used) { + pval* retval = decode_request_worker(xml, encoding, method); + if(retval) { + *return_value = *retval; + zval_copy_ctor(return_value); + } + } +} +/* }}} */ + + +/* {{{ proto array xmlrpc_decode(string xml, [string encoding]) + decode xml into native php types */ +PHP_FUNCTION(xmlrpc_decode) +{ + pval* arg1, *arg2 = NULL; + + if( !(ARG_COUNT(ht) == 1 || ARG_COUNT(ht) == 2) || getParameters(ht, ARG_COUNT(ht), &arg1, &arg2) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + convert_to_string(arg1); + if(ARG_COUNT(ht) == 2) { + convert_to_string(arg2); + } + + if(return_value_used) { + pval* retval = decode_request_worker(arg1, arg2, NULL); + if(retval) { + *return_value = *retval; + zval_copy_ctor(return_value); + } + } +} +/* }}} */ + + +/************************* +* server related methods * +*************************/ + +/* {{{ proto handle xmlrpc_server_create() + create an xmlrpc server */ +PHP_FUNCTION(xmlrpc_server_create) { + if(ARG_COUNT(ht) != 0) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + if(return_value_used) { + pval *method_map, *introspection_map; + MAKE_STD_ZVAL(method_map); + MAKE_STD_ZVAL(introspection_map); + + if(array_init(method_map) == SUCCESS && array_init(introspection_map) == SUCCESS) { + /* allocate server data. free'd in destroy_server_data() */ + xmlrpc_server_data *server = emalloc(sizeof(xmlrpc_server_data)); + + if(server) { + server->method_map = method_map; + server->introspection_map = introspection_map; + server->server_ptr = XMLRPC_ServerCreate(); + + XMLRPC_ServerRegisterIntrospectionCallback(server->server_ptr, php_xmlrpc_introspection_callback); + + /* store for later use */ + ZEND_REGISTER_RESOURCE(return_value,server, XMLRPCG(le_xmlrpc_server)); + } + } + } +} + +/* {{{ proto void xmlrpc_server_destroy(handle server) + destroy server resources */ +PHP_FUNCTION(xmlrpc_server_destroy) { + pval* arg1; + int bSuccess = FAILURE; + + if(ARG_COUNT(ht) != 1 || getParameters(ht, 1, &arg1) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + if(arg1->type == IS_RESOURCE) { + int type; + + xmlrpc_server_data *server = zend_list_find(arg1->value.lval, &type); + + if(server && type == XMLRPCG(le_xmlrpc_server)) { + bSuccess = zend_list_delete(arg1->value.lval); + + /* called by hashtable destructor + * destroy_server_data(server); + */ + } + } + RETVAL_LONG(bSuccess == SUCCESS); +} + + +/* called by xmlrpc C engine as method handler for all registered methods. + * it then calls the corresponding PHP function to handle the method. + */ +static XMLRPC_VALUE php_xmlrpc_callback(XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* data) { + pval *retval_ptr; + xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data; + pval* xmlrpc_params; + pval* callback_params[3]; + + /* convert xmlrpc to native php types */ + xmlrpc_params = XMLRPC_to_PHP(XMLRPC_RequestGetData(xRequest)); + + /* setup data hoojum */ + callback_params[0] = pData->xmlrpc_method; + callback_params[1] = xmlrpc_params; + callback_params[2] = pData->caller_params; + + /* Use same C function for all methods */ + + /* php func prototype: function user_func($method_name, $xmlrpc_params, $user_params) */ + call_user_function(CG(function_table), NULL, pData->php_function, pData->return_data, 3, callback_params); + + pData->php_executed = 1; +} + +/* called by the C server when it first receives an introspection request. We pass this on to + * our PHP listeners, if any + */ +static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data) { + pval *retval_ptr, **php_function; + pval* callback_params[1]; + xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data; + + MAKE_STD_ZVAL(retval_ptr); + retval_ptr->type = IS_NULL; + + /* setup data hoojum */ + callback_params[0] = pData->caller_params; + + /* loop through and call all registered callbacks */ + zend_hash_internal_pointer_reset(pData->server->introspection_map->value.ht); + while(1) { + if(zend_hash_get_current_data(pData->server->introspection_map->value.ht, + (void**)&php_function) == SUCCESS) { + + /* php func prototype: function string user_func($user_params) */ + if(call_user_function(CG(function_table), NULL, *php_function, + retval_ptr, 1, callback_params) == SUCCESS) { + XMLRPC_VALUE xData; + STRUCT_XMLRPC_ERROR err = {0}; + + /* return value should be a string */ + convert_to_string(retval_ptr); + + xData = XMLRPC_IntrospectionCreateDescription(retval_ptr->value.str.val, &err); + + if(xData) { + if(!XMLRPC_ServerAddIntrospectionData(server, xData)) { + zend_error(E_WARNING, "Unable to add introspection data returned from %s(), improper element structure", (*php_function)->value.str.val); + } + XMLRPC_CleanupValue(xData); + } + else { + /* could not create description */ + if(err.xml_elem_error.parser_code) { + zend_error(E_WARNING, "xml parse error: [line %i, column %i, message: %s] Unable to add introspection data returned from %s()", + err.xml_elem_error.column, err.xml_elem_error.line, err.xml_elem_error.parser_error, (*php_function)->value.str.val); + } + else { + zend_error(E_WARNING, "Unable to add introspection data returned from %s()", + (*php_function)->value.str.val); + } + } + } + else { + /* user func failed */ + zend_error(E_WARNING, "Error calling user introspection callback: %s()", (*php_function)->value.str.val); + } + } + else { + break; + } + + zend_hash_move_forward(pData->server->introspection_map->value.ht); + } + + /* so we don't call the same callbacks ever again */ + zend_hash_clean(pData->server->introspection_map->value.ht); +} + +/* {{{ proto boolean xmlrpc_server_register_method(handle server, string method_name, string function) + register a php function to handle method matching method_name */ +PHP_FUNCTION(xmlrpc_server_register_method) { + + pval* method_key, *method_name, *handle, *method_name_save; + int type; + xmlrpc_server_data* server; + + /* get some params. should be 3 */ + if( !(ARG_COUNT(ht) == 3) || getParameters(ht, ARG_COUNT(ht), &handle, &method_key, &method_name) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + server = zend_list_find(handle->value.lval, &type); + + if(type == XMLRPCG(le_xmlrpc_server)) { + /* register with C engine. every method just calls our standard callback, + * and it then dispatches to php as necessary + */ + if(XMLRPC_ServerRegisterMethod(server->server_ptr, method_key->value.str.val, php_xmlrpc_callback)) { + /* save for later use */ + MAKE_STD_ZVAL(method_name_save); + *method_name_save = *method_name; + zval_copy_ctor(method_name_save); + + /* register our php method */ + add_pval(server->method_map, method_key->value.str.val, &method_name_save); + + RETURN_BOOL(1); + } + } + RETURN_BOOL(0); +} + + +/* {{{ proto boolean xmlrpc_server_register_introspection_callback(handle server, string function) + register a php function to generate documentation */ +PHP_FUNCTION(xmlrpc_server_register_introspection_callback) { + + pval* method_key, *method_name, *handle, *method_name_save; + int type; + xmlrpc_server_data* server; + + /* get some params. should be 2 */ + if( !(ARG_COUNT(ht) == 2) || getParameters(ht, ARG_COUNT(ht), &handle, &method_name) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + server = zend_list_find(handle->value.lval, &type); + + if(type == XMLRPCG(le_xmlrpc_server)) { + { + /* save for later use */ + MAKE_STD_ZVAL(method_name_save); + *method_name_save = *method_name; + zval_copy_ctor(method_name_save); + + /* register our php method */ + add_pval(server->introspection_map, NULL, &method_name_save); + + RETURN_BOOL(1); + } + } + RETURN_BOOL(0); +} + + +/* this function is itchin for a re-write */ + +/* {{{ proto mixed xmlrpc_server_call_method(handle server, string xml, mixed user_data, [array output_options]) + parse xml request and call method */ +PHP_FUNCTION(xmlrpc_server_call_method) { + xmlrpc_callback_data data = {0}; + XMLRPC_REQUEST xRequest; + STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS input_opts; + xmlrpc_server_data* server; + pval *rawxml, *caller_params, *handle, *output_opts; + int type; + php_output_options out; + + /* get params. 3 or 4 params ok */ + if(ARG_COUNT(ht) == 4) { + if(getParameters(ht, ARG_COUNT(ht), &handle, &rawxml, &caller_params, &output_opts) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + /* user output options */ + set_output_options(&out, output_opts); + } + else if(ARG_COUNT(ht) == 3) { + if(getParameters(ht, ARG_COUNT(ht), &handle, &rawxml, &caller_params) != SUCCESS) { + WRONG_PARAM_COUNT; + } + /* user output options */ + set_output_options(&out, NULL); + } + else { + WRONG_PARAM_COUNT; + } + + server = zend_list_find(handle->value.lval, &type); + + if(type == XMLRPCG(le_xmlrpc_server)) { + /* HACK: use output encoding for now */ + input_opts.xml_elem_opts.encoding = utf8_get_encoding_id_from_string(out.xmlrpc_out.xml_elem_opts.encoding); + + /* generate an XMLRPC_REQUEST from the raw xml input */ + xRequest = XMLRPC_REQUEST_FromXML(rawxml->value.str.val, rawxml->value.str.len, &input_opts); + + if(xRequest) { + + /* check if we have a method name -- indicating success and all manner of good things */ + if(XMLRPC_RequestGetMethodName(xRequest)) { + pval** php_function, *returned = NULL; + XMLRPC_VALUE xAnswer = NULL; + MAKE_STD_ZVAL(data.xmlrpc_method); /* init. very important. spent a frustrating day finding this out. */ + MAKE_STD_ZVAL(data.return_data); + data.return_data->type = IS_NULL; /* in case value is never init'd, we don't dtor to think it is a string or something */ + data.xmlrpc_method->type = IS_NULL; + + /* setup some data to pass to the callback function */ + data.xmlrpc_method->value.str.val = estrdup(XMLRPC_RequestGetMethodName(xRequest)); + data.xmlrpc_method->value.str.len = strlen(data.xmlrpc_method->value.str.val); + data.xmlrpc_method->type = IS_STRING; + data.caller_params = caller_params; + data.php_executed = 0; + data.server = server; + + /* check if the called method has been previous registered */ + if(zend_hash_find(server->method_map->value.ht, + data.xmlrpc_method->value.str.val, + data.xmlrpc_method->value.str.len + 1, + (void**)&php_function) == SUCCESS) { + + data.php_function = *php_function; + } + + /* We could just call the php method directly ourselves at this point, but we do this + * with a C callback in case the xmlrpc library ever implements some cool usage stats, + * or somesuch. + */ + xAnswer = XMLRPC_ServerCallMethod(server->server_ptr, xRequest, &data); + if(xAnswer) { + if(out.b_php_out) { + zval_dtor(data.return_data); + FREE_ZVAL(data.return_data); + data.return_data = XMLRPC_to_PHP(xAnswer); + } + } + else if(data.php_executed) { + if(!out.b_php_out) { + xAnswer = PHP_to_XMLRPC(data.return_data); + } + } + + /* should we return data as xml? */ + if(!out.b_php_out) { + XMLRPC_REQUEST xResponse = XMLRPC_RequestNew(); + if(xResponse) { + char* outBuf = 0; + int buf_len = 0; + + /* set some required request hoojum */ + XMLRPC_RequestSetOutputOptions(xResponse, &out.xmlrpc_out); + XMLRPC_RequestSetRequestType(xResponse, xmlrpc_request_response); + XMLRPC_RequestSetData(xResponse, xAnswer); + + /* generate xml */ + outBuf = XMLRPC_REQUEST_ToXML(xResponse, &buf_len); + if(outBuf) { + RETVAL_STRINGL(outBuf, buf_len, 1); + free(outBuf); + } + /* cleanup after ourselves. what a sty! */ + XMLRPC_RequestFree(xResponse, 0); + } + } + /* or as native php types? */ + else { + *return_value = *data.return_data; + zval_copy_ctor(return_value); + } + + /* cleanup after ourselves. what a sty! */ + zval_dtor(data.xmlrpc_method); + FREE_ZVAL(data.xmlrpc_method); + zval_dtor(data.return_data); + FREE_ZVAL(data.return_data); + + if(xAnswer) { + XMLRPC_CleanupValue(xAnswer); + } + } + + XMLRPC_RequestFree(xRequest, 1); + } + } +} + + +/* {{{ proto int xmlrpc_server_add_introspection_data(handle server, array desc) + add introspection documentation */ +PHP_FUNCTION(xmlrpc_server_add_introspection_data) { + + pval *method, *handle, *desc; + int type; + xmlrpc_server_data* server; + + /* get some params. should be 2 */ + if ( !(ARG_COUNT(ht) == 2) || getParameters(ht, ARG_COUNT(ht), &handle, &desc) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + server = zend_list_find(handle->value.lval, &type); + + if (type == XMLRPCG(le_xmlrpc_server)) { + XMLRPC_VALUE xDesc = PHP_to_XMLRPC(desc); + if (xDesc) { + int retval = XMLRPC_ServerAddIntrospectionData(server->server_ptr, xDesc); + XMLRPC_CleanupValue(xDesc); + RETURN_LONG(retval); + } + } + RETURN_LONG(0); +} + + +/* {{{ proto array xmlrpc_parse_method_descriptions(string xml) + decode xml into a list of method descriptions */ +PHP_FUNCTION(xmlrpc_parse_method_descriptions) +{ + pval* arg1, *arg2, *retval; + + if( !(ARG_COUNT(ht) == 1) || getParameters(ht, ARG_COUNT(ht), &arg1) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + convert_to_string(arg1); + + if(return_value_used) { + STRUCT_XMLRPC_ERROR err = {0}; + XMLRPC_VALUE xVal = XMLRPC_IntrospectionCreateDescription(arg1->value.str.val, &err); + if(xVal) { + retval = XMLRPC_to_PHP(xVal); + + if(retval) { + *return_value = *retval; + zval_copy_ctor(return_value); + } + /* dust, sweep, and mop */ + XMLRPC_CleanupValue(xVal); + } + else { + /* could not create description */ + if(err.xml_elem_error.parser_code) { + zend_error(E_WARNING, "xml parse error: [line %i, column %i, message: %s] Unable to create introspection data", + err.xml_elem_error.column, err.xml_elem_error.line, err.xml_elem_error.parser_error); + } + else { + zend_error(E_WARNING, "Invalid xml structure. Unable to create introspection data"); + } + + zend_error(E_WARNING, "xml parse error. no method description created"); + } + } +} + + +/************ +* type data * +************/ + +#define XMLRPC_TYPE_COUNT 9 +#define XMLRPC_VECTOR_TYPE_COUNT 4 +#define TYPE_STR_MAP_SIZE (XMLRPC_TYPE_COUNT + XMLRPC_VECTOR_TYPE_COUNT) + +/* return a string matching a given xmlrpc type */ +static const char** get_type_str_mapping() { + static const char* str_mapping[TYPE_STR_MAP_SIZE]; + static int first = 1; + if(first) { + /* warning. do not add/delete without changing size define */ + str_mapping[xmlrpc_none] = "none"; + str_mapping[xmlrpc_empty] = "empty"; + str_mapping[xmlrpc_base64] = "base64"; + str_mapping[xmlrpc_boolean] = "boolean"; + str_mapping[xmlrpc_datetime] = "datetime"; + str_mapping[xmlrpc_double] = "double"; + str_mapping[xmlrpc_int] = "int"; + str_mapping[xmlrpc_string] = "string"; + str_mapping[xmlrpc_vector] = "vector"; + str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_none] = "none"; + str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_array] = "array"; + str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_mixed] = "mixed"; + str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_struct] = "struct"; + first = 0; + } + return (const char**)str_mapping; +} + +/* map an xmlrpc type to a string */ +const char* xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype) { + const char** str_mapping = get_type_str_mapping(); + if(vtype == xmlrpc_vector_none) { + return str_mapping[type]; + } + else { + return str_mapping[XMLRPC_TYPE_COUNT + vtype]; + } +} + +/* map a string to an xmlrpc type */ +XMLRPC_VALUE_TYPE xmlrpc_str_as_type(const char* str) { + const char** str_mapping = get_type_str_mapping(); + int i; + + if(str) { + for(i = 0; i < XMLRPC_TYPE_COUNT; i++) { + if(!strcmp(str_mapping[i], str)) { + return (XMLRPC_VALUE_TYPE)i; + } + } + } + return xmlrpc_none; +} + +/* map a string to an xmlrpc vector type */ +XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str) { + const char** str_mapping = get_type_str_mapping(); + int i; + + if(str) { + for(i = XMLRPC_TYPE_COUNT; i < TYPE_STR_MAP_SIZE; i++) { + if(!strcmp(str_mapping[i], str)) { + return (XMLRPC_VECTOR_TYPE)(i - XMLRPC_TYPE_COUNT); + } + } + } + return xmlrpc_none; +} + + +/* set a given value to a particular type. + * note: this only works on strings, and only for date and base64, + * which do not have native php types. black magic lies herein. + */ +int set_pval_xmlrpc_type(pval* value, XMLRPC_VALUE_TYPE type) { + int bSuccess = FAILURE; + + /* we only really care about strings because they can represent + * base64 and datetime. all other types have corresponding php types + */ + if(value->type == IS_STRING) { + if(type == xmlrpc_base64 || type == xmlrpc_datetime) { + const char* typestr = xmlrpc_type_as_str(type, xmlrpc_vector_none); + pval* type; + + MAKE_STD_ZVAL(type); + + type->type = IS_STRING; + type->value.str.val = estrdup(typestr); + type->value.str.len = strlen(typestr); + + convert_to_object(value); + bSuccess = zend_hash_update(value->value.obj.properties, OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR), (void *) &type, sizeof(zval *), NULL); + } + } + + return bSuccess; +} + +/* return xmlrpc type of a php value */ +XMLRPC_VALUE_TYPE get_pval_xmlrpc_type(pval* value, pval** newvalue) { + XMLRPC_VALUE_TYPE type = xmlrpc_none; + + if(value) { + switch(value->type) { + case IS_NULL: + type = xmlrpc_base64; + break; + #ifndef BOOL_AS_LONG + + /* Right thing to do, but it breaks some legacy code. */ + case IS_BOOL: + type = xmlrpc_boolean; + break; + #else + case IS_BOOL: + #endif + case IS_LONG: + case IS_RESOURCE: + type = xmlrpc_int; + break; + case IS_DOUBLE: + type = xmlrpc_double; + break; + case IS_CONSTANT: + type = xmlrpc_string; + break; + case IS_STRING: + type = xmlrpc_string; + break; + case IS_ARRAY: + case IS_CONSTANT_ARRAY: + type = xmlrpc_vector; + break; + case IS_OBJECT: + { + pval** attr; + type = xmlrpc_vector; + + if(zend_hash_find(value->value.obj.properties, + OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR), + (void**)&attr) == SUCCESS) { + if((*attr)->type == IS_STRING) { + type = xmlrpc_str_as_type((*attr)->value.str.val); + } + } + break; + } + } + + /* if requested, return an unmolested (magic removed) copy of the value */ + if(newvalue) { + pval** val; + if( (type == xmlrpc_base64 && value->type != IS_NULL) || type == xmlrpc_datetime) { + if(zend_hash_find(value->value.obj.properties, + OBJECT_VALUE_ATTR, sizeof(OBJECT_VALUE_ATTR), + (void**)&val) == SUCCESS) { + *newvalue = *val; + } + } + else { + *newvalue = value; + } + } + } + + return type; +} + + +/* {{{ proto bool xmlrpc_set_type(string value, string type) + set xmlrpc type, base64 or datetime, for a php string value */ +PHP_FUNCTION(xmlrpc_set_type) { + pval* arg, *type; + XMLRPC_VALUE_TYPE vtype; + + if( !(ARG_COUNT(ht) == 2) || getParameters(ht, ARG_COUNT(ht), &arg, &type) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } +#if ZEND_MODULE_API_NO < 20010901 + if (!ParameterPassedByReference(ht,1)) { + zend_error(E_WARNING,"first argument to xmlrpc_set_type() passed by value, expecting reference"); + } +#endif + + convert_to_string(type); + vtype = xmlrpc_str_as_type(type->value.str.val); + if(vtype != xmlrpc_none) { + if(set_pval_xmlrpc_type(arg, vtype) == SUCCESS) { + RETURN_TRUE; + } + } + else { + zend_error(E_WARNING,"invalid type '%s' passed to xmlrpc_set_type()", type->value.str.val); + } + RETURN_FALSE; +} + +/* {{{ proto string xmlrpc_get_type(mixed value) + get xmlrpc type for a php value. especially useful for base64 and datetime strings */ +PHP_FUNCTION(xmlrpc_get_type) { + pval* arg; + XMLRPC_VALUE_TYPE type; + XMLRPC_VECTOR_TYPE vtype = xmlrpc_vector_none; + + if( !(ARG_COUNT(ht) == 1) || getParameters(ht, ARG_COUNT(ht), &arg) == FAILURE) { + WRONG_PARAM_COUNT; /* prints/logs a warning and returns */ + } + + type = get_pval_xmlrpc_type(arg, 0); + if(type == xmlrpc_vector) { + vtype = determine_vector_type(arg->value.ht); + } + + RETURN_STRING((char*)xmlrpc_type_as_str(type, vtype), 1); +} + + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + */ + |