#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "ext/standard/info.h"
#include "ext/standard/php_string.h"
#include "ext/date/php_date.h"
#include "php_ini.h"
#include "php_xmlrpc.h"
#include "xmlrpc.h"
static int le_xmlrpc_server;
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_encode, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_decode, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_ARG_INFO(0, encoding)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_decode_request, 0, 0, 2)
ZEND_ARG_INFO(0, xml)
ZEND_ARG_INFO(1, method)
ZEND_ARG_INFO(0, encoding)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_encode_request, 0, 0, 2)
ZEND_ARG_INFO(0, method)
ZEND_ARG_INFO(0, params)
ZEND_ARG_INFO(0, output_options)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_set_type, 0, 0, 2)
ZEND_ARG_INFO(1, value)
ZEND_ARG_INFO(0, type)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_is_fault, 0, 0, 1)
ZEND_ARG_INFO(0, arg)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO(arginfo_xmlrpc_server_create, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_destroy, 0, 0, 1)
ZEND_ARG_INFO(0, server)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_register_method, 0, 0, 3)
ZEND_ARG_INFO(0, server)
ZEND_ARG_INFO(0, method_name)
ZEND_ARG_INFO(0, function)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_call_method, 0, 0, 3)
ZEND_ARG_INFO(0, server)
ZEND_ARG_INFO(0, xml)
ZEND_ARG_INFO(0, user_data)
ZEND_ARG_INFO(0, output_options)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_parse_method_descriptions, 0, 0, 1)
ZEND_ARG_INFO(0, xml)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_add_introspection_data, 0, 0, 2)
ZEND_ARG_INFO(0, server)
ZEND_ARG_INFO(0, desc)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_register_introspection_callback, 0, 0, 2)
ZEND_ARG_INFO(0, server)
ZEND_ARG_INFO(0, function)
ZEND_END_ARG_INFO()
const zend_function_entry xmlrpc_functions[] = {
PHP_FE(xmlrpc_encode, arginfo_xmlrpc_encode)
PHP_FE(xmlrpc_decode, arginfo_xmlrpc_decode)
PHP_FE(xmlrpc_decode_request, arginfo_xmlrpc_decode_request)
PHP_FE(xmlrpc_encode_request, arginfo_xmlrpc_encode_request)
PHP_FE(xmlrpc_get_type, arginfo_xmlrpc_encode)
PHP_FE(xmlrpc_set_type, arginfo_xmlrpc_set_type)
PHP_FE(xmlrpc_is_fault, arginfo_xmlrpc_is_fault)
PHP_FE(xmlrpc_server_create, arginfo_xmlrpc_server_create)
PHP_FE(xmlrpc_server_destroy, arginfo_xmlrpc_server_destroy)
PHP_FE(xmlrpc_server_register_method, arginfo_xmlrpc_server_register_method)
PHP_FE(xmlrpc_server_call_method, arginfo_xmlrpc_server_call_method)
PHP_FE(xmlrpc_parse_method_descriptions, arginfo_xmlrpc_parse_method_descriptions)
PHP_FE(xmlrpc_server_add_introspection_data, arginfo_xmlrpc_server_add_introspection_data)
PHP_FE(xmlrpc_server_register_introspection_callback, arginfo_xmlrpc_server_register_introspection_callback)
PHP_FE_END
};
zend_module_entry xmlrpc_module_entry = {
STANDARD_MODULE_HEADER,
"xmlrpc",
xmlrpc_functions,
PHP_MINIT(xmlrpc),
NULL,
NULL,
NULL,
PHP_MINFO(xmlrpc),
PHP_XMLRPC_VERSION,
STANDARD_MODULE_PROPERTIES
};
#ifdef COMPILE_DL_XMLRPC
ZEND_GET_MODULE(xmlrpc)
#endif
typedef struct _xmlrpc_server_data {
zval method_map;
zval introspection_map;
XMLRPC_SERVER server_ptr;
} xmlrpc_server_data;
typedef struct _php_output_options {
int b_php_out;
int b_auto_version;
STRUCT_XMLRPC_REQUEST_OUTPUT_OPTIONS xmlrpc_out;
} php_output_options;
typedef struct _xmlrpc_callback_data {
zval xmlrpc_method;
zval php_function;
zval caller_params;
zval return_data;
xmlrpc_server_data* server;
char php_executed;
} xmlrpc_callback_data;
#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 VERSION_VALUE_SOAP11 "soap 1.1"
#define VERSION_VALUE_AUTO "auto"
#define ENCODING_KEY "encoding"
#define ENCODING_KEY_LEN (sizeof(ENCODING_KEY) - 1)
#define ENCODING_DEFAULT "iso-8859-1"
#define OBJECT_TYPE_ATTR "xmlrpc_type"
#define OBJECT_VALUE_ATTR "scalar"
#define OBJECT_VALUE_TS_ATTR "timestamp"
#define FAULT_CODE "faultCode"
#define FAULT_CODE_LEN (sizeof(FAULT_CODE) - 1)
#define FAULT_STRING "faultString"
#define FAULT_STRING_LEN (sizeof(FAULT_STRING) - 1)
XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval* newvalue);
static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data);
int sset_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE type);
void decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval* method_name_out, zval *retval);
const char* xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype);
XMLRPC_VALUE_TYPE xmlrpc_str_as_type(const char* str);
XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str);
int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE type);
static void destroy_server_data(xmlrpc_server_data *server)
{
if (server) {
XMLRPC_ServerDestroy(server->server_ptr);
zval_ptr_dtor(&server->method_map);
zval_ptr_dtor(&server->introspection_map);
efree(server);
}
}
static void xmlrpc_server_destructor(zend_resource *rsrc)
{
if (rsrc && rsrc->ptr) {
rsrc->gc.refcount++;
destroy_server_data((xmlrpc_server_data*) rsrc->ptr);
rsrc->gc.refcount--;
}
}
PHP_MINIT_FUNCTION(xmlrpc)
{
le_xmlrpc_server = zend_register_list_destructors_ex(xmlrpc_server_destructor, NULL, "xmlrpc server", module_number);
return SUCCESS;
}
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_XMLRPC_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();
}
#if 0
static int add_long(zval* 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(zval* 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(zval* list, char* id, char* string) {
if(id) return add_assoc_string(list, id, string);
else return add_next_index_string(list, string);
}
static int add_stringl(zval* list, char* id, char* string, uint length) {
if(id) return add_assoc_stringl(list, id, string, length);
else return add_next_index_stringl(list, string, length);
}
#endif
static void add_zval(zval* list, const char* id, zval* val)
{
if (list && val) {
if (id) {
int id_len = strlen(id);
if (!(id_len > 1 && id[0] == '0') && is_numeric_string((char *)id, id_len, NULL, NULL, 0) == IS_LONG) {
long index = strtol(id, NULL, 0);
zend_hash_index_update(Z_ARRVAL_P(list), index, val);
} else {
zend_hash_str_update(Z_ARRVAL_P(list), (char*)id, strlen(id), val);
}
} else {
zend_hash_next_index_insert(Z_ARRVAL_P(list), val);
}
}
}
static void set_output_options(php_output_options* options, zval* output_opts)
{
if (options) {
options->b_php_out = 0;
options->b_auto_version = 1;
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 && Z_TYPE_P(output_opts) == IS_ARRAY) {
zval* val;
if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), OUTPUT_TYPE_KEY, OUTPUT_TYPE_KEY_LEN)) != NULL) {
if (Z_TYPE_P(val) == IS_STRING) {
if (!strcmp(Z_STRVAL_P(val), OUTPUT_TYPE_VALUE_PHP)) {
options->b_php_out = 1;
} else if (!strcmp(Z_STRVAL_P(val), OUTPUT_TYPE_VALUE_XML)) {
options->b_php_out = 0;
}
}
}
if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), VERBOSITY_KEY, VERBOSITY_KEY_LEN)) != NULL) {
if (Z_TYPE_P(val) == IS_STRING) {
if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_NO_WHITE_SPACE)) {
options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_no_white_space;
} else if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_NEWLINES_ONLY)) {
options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_newlines_only;
} else if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_PRETTY)) {
options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_pretty;
}
}
}
if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), VERSION_KEY, VERSION_KEY_LEN)) != NULL) {
if (Z_TYPE_P(val) == IS_STRING) {
options->b_auto_version = 0;
if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_XMLRPC)) {
options->xmlrpc_out.version = xmlrpc_version_1_0;
} else if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_SIMPLE)) {
options->xmlrpc_out.version = xmlrpc_version_simple;
} else if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_SOAP11)) {
options->xmlrpc_out.version = xmlrpc_version_soap_1_1;
} else {
options->b_auto_version = 1;
}
}
}
if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), ENCODING_KEY, ENCODING_KEY_LEN)) != NULL) {
if (Z_TYPE_P(val) == IS_STRING) {
options->xmlrpc_out.xml_elem_opts.encoding = estrdup(Z_STRVAL_P(val));
}
}
if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), ESCAPING_KEY, ESCAPING_KEY_LEN)) != NULL) {
if (Z_TYPE_P(val) == IS_ARRAY) {
zval* iter_val;
options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_no_escaping;
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(val), iter_val) {
if (Z_TYPE_P(iter_val) == IS_STRING && Z_STRVAL_P(iter_val)) {
if (!strcmp(Z_STRVAL_P(iter_val), ESCAPING_VALUE_CDATA)) {
options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_cdata_escaping;
} else if (!strcmp(Z_STRVAL_P(iter_val), ESCAPING_VALUE_NON_ASCII)) {
options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_ascii_escaping;
} else if (!strcmp(Z_STRVAL_P(iter_val), ESCAPING_VALUE_NON_PRINT)) {
options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_print_escaping;
} else if (!strcmp(Z_STRVAL_P(iter_val), ESCAPING_VALUE_MARKUP)) {
options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_markup_escaping;
}
}
} ZEND_HASH_FOREACH_END();
} else if (Z_TYPE_P(val) == IS_STRING) {
if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_CDATA)) {
options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_cdata_escaping;
} else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_NON_ASCII)) {
options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_ascii_escaping;
} else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_NON_PRINT)) {
options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_print_escaping;
} else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_MARKUP)) {
options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping;
}
}
}
}
}
}
static XMLRPC_VECTOR_TYPE determine_vector_type (HashTable *ht)
{
int bArray = 0, bStruct = 0, bMixed = 0;
zend_ulong num_index, last_num = 0;
zend_string* my_key;
ZEND_HASH_FOREACH_KEY(ht, num_index, my_key) {
if (my_key == NULL) {
if (bStruct) {
bMixed = 1;
break;
} else if (last_num > 0 && last_num != num_index-1) {
bStruct = 1;
break;
}
bArray = 1;
last_num = num_index;
} else {
if (bArray) {
bMixed = 1;
break;
}
bStruct = 1;
}
} ZEND_HASH_FOREACH_END();
return bMixed ? xmlrpc_vector_mixed : (bStruct ? xmlrpc_vector_struct : xmlrpc_vector_array);
}
static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int depth)
{
XMLRPC_VALUE xReturn = NULL;
if (in_val) {
zval val;
XMLRPC_VALUE_TYPE type;
ZVAL_UNDEF(&val);
type = get_zval_xmlrpc_type(in_val, &val);
if (!Z_ISUNDEF(val)) {
switch (type) {
case xmlrpc_base64:
if (Z_TYPE(val) == IS_NULL) {
xReturn = XMLRPC_CreateValueEmpty();
XMLRPC_SetValueID(xReturn, key, 0);
} else {
if (Z_TYPE(val) != IS_STRING) {
zval newvalue;
ZVAL_DUP(&newvalue, &val);
convert_to_string(&newvalue);
xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL(newvalue), Z_STRLEN(newvalue));
zval_dtor(&newvalue);
} else {
xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL(val), Z_STRLEN(val));
}
}
break;
case xmlrpc_datetime:
convert_to_string(&val);
xReturn = XMLRPC_CreateValueDateTime_ISO8601(key, Z_STRVAL(val));
break;
case xmlrpc_boolean:
convert_to_boolean(&val);
xReturn = XMLRPC_CreateValueBoolean(key, Z_TYPE(val) == IS_TRUE);
break;
case xmlrpc_int:
ZVAL_LONG(&val, zval_get_long(&val));
xReturn = XMLRPC_CreateValueInt(key, Z_LVAL(val));
break;
case xmlrpc_double:
convert_to_double(&val);
xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL(val));
break;
case xmlrpc_string:
convert_to_string(&val);
xReturn = XMLRPC_CreateValueString(key, Z_STRVAL(val), Z_STRLEN(val));
break;
case xmlrpc_vector:
{
zend_ulong num_index;
zval* pIter;
zend_string* my_key;
HashTable *ht = NULL;
zval val_arr;
XMLRPC_VECTOR_TYPE vtype;
ht = HASH_OF(&val);
if (ht && ht->u.v.nApplyCount > 1) {
zend_throw_error(NULL, "XML-RPC doesn't support circular references");
return NULL;
}
ZVAL_COPY(&val_arr, &val);
convert_to_array(&val_arr);
vtype = determine_vector_type(Z_ARRVAL(val_arr));
xReturn = XMLRPC_CreateVector(key, vtype);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL(val_arr), num_index, my_key, pIter) {
ZVAL_DEREF(pIter);
ht = HASH_OF(pIter);
if (ht) {
ht->u.v.nApplyCount++;
}
if (my_key == NULL) {
char *num_str = NULL;
if (vtype != xmlrpc_vector_array) {
spprintf(&num_str, 0, ZEND_LONG_FMT, num_index);
}
XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(num_str, pIter, depth++));
if (num_str) {
efree(num_str);
}
} else {
XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(ZSTR_VAL(my_key), pIter, depth++));
}
if (ht) {
ht->u.v.nApplyCount--;
}
} ZEND_HASH_FOREACH_END();
zval_ptr_dtor(&val_arr);
}
break;
default:
break;
}
}
}
return xReturn;
}
static XMLRPC_VALUE PHP_to_XMLRPC(zval* root_val)
{
return PHP_to_XMLRPC_worker(NULL, root_val, 0);
}
static void XMLRPC_to_PHP(XMLRPC_VALUE el, zval *elem)
{
const char* pStr;
if (el) {
XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(el);
switch (type) {
case xmlrpc_empty:
ZVAL_NULL(elem);
break;
case xmlrpc_string:
pStr = XMLRPC_GetValueString(el);
if (pStr) {
ZVAL_STRINGL(elem, pStr, XMLRPC_GetValueStringLen(el));
}
break;
case xmlrpc_int:
ZVAL_LONG(elem, XMLRPC_GetValueInt(el));
break;
case xmlrpc_boolean:
ZVAL_BOOL(elem, XMLRPC_GetValueBoolean(el));
break;
case xmlrpc_double:
ZVAL_DOUBLE(elem, XMLRPC_GetValueDouble(el));
break;
case xmlrpc_datetime:
ZVAL_STRINGL(elem, XMLRPC_GetValueDateTime_ISO8601(el), XMLRPC_GetValueStringLen(el));
break;
case xmlrpc_base64:
pStr = XMLRPC_GetValueBase64(el);
if (pStr) {
ZVAL_STRINGL(elem, pStr, XMLRPC_GetValueStringLen(el));
}
break;
case xmlrpc_vector:
array_init(elem);
{
XMLRPC_VALUE xIter = XMLRPC_VectorRewind(el);
while( xIter ) {
zval val;
ZVAL_UNDEF(&val);
XMLRPC_to_PHP(xIter, &val);
if (!Z_ISUNDEF(val)) {
add_zval(elem, XMLRPC_GetValueID(xIter), &val);
}
xIter = XMLRPC_VectorNext(el);
}
}
break;
default:
break;
}
set_zval_xmlrpc_type(elem, type);
}
}
PHP_FUNCTION(xmlrpc_encode_request)
{
XMLRPC_REQUEST xRequest = NULL;
char *outBuf;
zval *vals, *out_opts = NULL;
char *method = NULL;
size_t method_len;
php_output_options out;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!z|a", &method, &method_len, &vals, &out_opts) == FAILURE) {
return;
}
set_output_options(&out, out_opts ? out_opts : 0);
if (USED_RET()) {
xRequest = XMLRPC_RequestNew();
if (xRequest) {
XMLRPC_RequestSetOutputOptions(xRequest, &out.xmlrpc_out);
if (method == NULL) {
XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_response);
} else {
XMLRPC_RequestSetMethodName(xRequest, method);
XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_call);
}
if (Z_TYPE_P(vals) != IS_NULL) {
XMLRPC_RequestSetData(xRequest, PHP_to_XMLRPC(vals));
}
outBuf = XMLRPC_REQUEST_ToXML(xRequest, 0);
if (outBuf) {
RETVAL_STRING(outBuf);
free(outBuf);
}
XMLRPC_RequestFree(xRequest, 1);
}
}
if (strcmp(out.xmlrpc_out.xml_elem_opts.encoding, ENCODING_DEFAULT) != 0) {
efree((char *)out.xmlrpc_out.xml_elem_opts.encoding);
}
}
PHP_FUNCTION(xmlrpc_encode)
{
XMLRPC_VALUE xOut = NULL;
zval *arg1;
char *outBuf;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg1) == FAILURE) {
return;
}
if (USED_RET()) {
xOut = PHP_to_XMLRPC(arg1);
outBuf = XMLRPC_VALUE_ToXML(xOut, 0);
if (xOut) {
if (outBuf) {
RETVAL_STRING(outBuf);
free(outBuf);
}
XMLRPC_CleanupValue(xOut);
}
}
}
void decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval* method_name_out, zval *retval)
{
XMLRPC_REQUEST response;
STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS opts = {{0}};
const char *method_name;
opts.xml_elem_opts.encoding = encoding_in ? utf8_get_encoding_id_from_string(encoding_in) : ENCODING_DEFAULT;
response = XMLRPC_REQUEST_FromXML(xml_in, xml_in_len, &opts);
if (response) {
ZVAL_NULL(retval);
XMLRPC_to_PHP(XMLRPC_RequestGetData(response), retval);
if (XMLRPC_RequestGetRequestType(response) == xmlrpc_request_call) {
if (method_name_out) {
method_name = XMLRPC_RequestGetMethodName(response);
if (method_name) {
zval_ptr_dtor(method_name_out);
ZVAL_STRING(method_name_out, method_name);
} else {
zval_ptr_dtor(retval);
ZVAL_NULL(retval);
}
}
}
XMLRPC_RequestFree(response, 1);
}
}
PHP_FUNCTION(xmlrpc_decode_request)
{
char *xml, *encoding = NULL;
zval *method;
size_t xml_len, encoding_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
return;
}
if (USED_RET()) {
decode_request_worker(xml, xml_len, encoding_len ? encoding : NULL, method, return_value);
}
}
PHP_FUNCTION(xmlrpc_decode)
{
char *arg1, *arg2 = NULL;
size_t arg1_len, arg2_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", &arg1, &arg1_len, &arg2, &arg2_len) == FAILURE) {
return;
}
if (USED_RET()) {
decode_request_worker(arg1, arg1_len, arg2_len ? arg2 : NULL, NULL, return_value);
}
}
PHP_FUNCTION(xmlrpc_server_create)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
if (USED_RET()) {
xmlrpc_server_data *server = emalloc(sizeof(xmlrpc_server_data));
array_init(&server->method_map);
array_init(&server->introspection_map);
server->server_ptr = XMLRPC_ServerCreate();
XMLRPC_ServerRegisterIntrospectionCallback(server->server_ptr, php_xmlrpc_introspection_callback);
RETURN_RES(zend_register_resource(server, le_xmlrpc_server));
}
}
PHP_FUNCTION(xmlrpc_server_destroy)
{
zval *arg1;
int bSuccess = FAILURE;
xmlrpc_server_data *server;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &arg1) == FAILURE) {
return;
}
if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(arg1), "xmlrpc server", le_xmlrpc_server)) == NULL) {
RETURN_FALSE;
}
bSuccess = zend_list_close(Z_RES_P(arg1));
RETURN_BOOL(bSuccess == SUCCESS);
}
static XMLRPC_VALUE php_xmlrpc_callback(XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* data)
{
xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
zval* php_function;
zval xmlrpc_params;
zval callback_params[3];
zval_ptr_dtor(&pData->xmlrpc_method);
zval_ptr_dtor(&pData->return_data);
ZVAL_STRING(&pData->xmlrpc_method, XMLRPC_RequestGetMethodName(xRequest));
XMLRPC_to_PHP(XMLRPC_RequestGetData(xRequest), &xmlrpc_params);
if ((php_function = zend_hash_find(Z_ARRVAL(pData->server->method_map), Z_STR(pData->xmlrpc_method))) != NULL) {
ZVAL_COPY_VALUE(&pData->php_function, php_function);
}
ZVAL_COPY_VALUE(&callback_params[0], &pData->xmlrpc_method);
ZVAL_COPY_VALUE(&callback_params[1], &xmlrpc_params);
ZVAL_COPY_VALUE(&callback_params[2], &pData->caller_params);
call_user_function(CG(function_table), NULL, &pData->php_function, &pData->return_data, 3, callback_params);
pData->php_executed = 1;
zval_ptr_dtor(&xmlrpc_params);
return PHP_to_XMLRPC(&pData->return_data);
}
static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data)
{
zval retval, *php_function;
zval callback_params[1];
zend_string *php_function_name;
xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
ZVAL_COPY_VALUE(&callback_params[0], &pData->caller_params);
ZEND_HASH_FOREACH_VAL(Z_ARRVAL(pData->server->introspection_map), php_function) {
if (zend_is_callable(php_function, 0, &php_function_name)) {
if (call_user_function(CG(function_table), NULL, php_function, &retval, 1, callback_params) == SUCCESS) {
XMLRPC_VALUE xData;
STRUCT_XMLRPC_ERROR err = {0};
convert_to_string(&retval);
xData = XMLRPC_IntrospectionCreateDescription(Z_STRVAL(retval), &err);
if (xData) {
if (!XMLRPC_ServerAddIntrospectionData(server, xData)) {
php_error_docref(NULL, E_WARNING, "Unable to add introspection data returned from %s(), improper element structure", ZSTR_VAL(php_function_name));
}
XMLRPC_CleanupValue(xData);
} else {
if (err.xml_elem_error.parser_code) {
php_error_docref(NULL, E_WARNING, "xml parse error: [line %ld, column %ld, 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, ZSTR_VAL(php_function_name));
} else {
php_error_docref(NULL, E_WARNING, "Unable to add introspection data returned from %s()", ZSTR_VAL(php_function_name));
}
}
zval_ptr_dtor(&retval);
} else {
php_error_docref(NULL, E_WARNING, "Error calling user introspection callback: %s()", ZSTR_VAL(php_function_name));
}
} else {
php_error_docref(NULL, E_WARNING, "Invalid callback '%s' passed", ZSTR_VAL(php_function_name));
}
zend_string_release(php_function_name);
} ZEND_HASH_FOREACH_END();
zend_hash_clean(Z_ARRVAL(pData->server->introspection_map));
}
PHP_FUNCTION(xmlrpc_server_register_method)
{
char *method_key;
size_t method_key_len;
zval *handle, *method_name;
xmlrpc_server_data* server;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz", &handle, &method_key, &method_key_len, &method_name) == FAILURE) {
return;
}
if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) {
RETURN_FALSE;
}
if (XMLRPC_ServerRegisterMethod(server->server_ptr, method_key, php_xmlrpc_callback)) {
if (Z_REFCOUNTED_P(method_name)) {
Z_ADDREF_P(method_name);
}
add_zval(&server->method_map, method_key, method_name);
RETURN_TRUE;
}
}
PHP_FUNCTION(xmlrpc_server_register_introspection_callback)
{
zval *method_name, *handle;
xmlrpc_server_data* server;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz", &handle, &method_name) == FAILURE) {
return;
}
if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) {
RETURN_FALSE;
}
if (Z_REFCOUNTED_P(method_name)) {
Z_ADDREF_P(method_name);
}
add_zval(&server->introspection_map, NULL, method_name);
RETURN_TRUE;
}
PHP_FUNCTION(xmlrpc_server_call_method)
{
XMLRPC_REQUEST xRequest;
xmlrpc_callback_data data;
STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS input_opts;
xmlrpc_server_data* server;
zval *caller_params, *handle, *output_opts = NULL;
char *rawxml;
size_t rawxml_len;
php_output_options out;
int argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz|a", &handle, &rawxml, &rawxml_len, &caller_params, &output_opts) != SUCCESS) {
return;
}
if (argc == 3) {
set_output_options(&out, NULL);
} else {
set_output_options(&out, output_opts);
}
if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) {
RETURN_FALSE;
}
input_opts.xml_elem_opts.encoding = utf8_get_encoding_id_from_string(out.xmlrpc_out.xml_elem_opts.encoding);
xRequest = XMLRPC_REQUEST_FromXML(rawxml, rawxml_len, &input_opts);
if (xRequest) {
const char* methodname = XMLRPC_RequestGetMethodName(xRequest);
XMLRPC_VALUE xAnswer = NULL;
ZVAL_NULL(&data.xmlrpc_method);
ZVAL_NULL(&data.return_data);
ZVAL_NULL(&data.return_data);
ZVAL_NULL(&data.xmlrpc_method);
ZVAL_COPY_VALUE(&data.caller_params, caller_params);
data.php_executed = 0;
data.server = server;
xAnswer = XMLRPC_ServerCallMethod(server->server_ptr, xRequest, &data);
if (xAnswer && out.b_php_out) {
XMLRPC_to_PHP(xAnswer, &data.return_data);
} else if (data.php_executed && !out.b_php_out && !xAnswer) {
xAnswer = PHP_to_XMLRPC(&data.return_data);
}
if (!out.b_php_out) {
XMLRPC_REQUEST xResponse = XMLRPC_RequestNew();
if (xResponse) {
char *outBuf = 0;
int buf_len = 0;
if (out.b_auto_version) {
XMLRPC_REQUEST_OUTPUT_OPTIONS opts = XMLRPC_RequestGetOutputOptions(xRequest);
if (opts) {
out.xmlrpc_out.version = opts->version;
}
}
XMLRPC_RequestSetOutputOptions(xResponse, &out.xmlrpc_out);
XMLRPC_RequestSetRequestType(xResponse, xmlrpc_request_response);
XMLRPC_RequestSetData(xResponse, xAnswer);
XMLRPC_RequestSetMethodName(xResponse, methodname);
outBuf = XMLRPC_REQUEST_ToXML(xResponse, &buf_len);
if (outBuf) {
RETVAL_STRINGL(outBuf, buf_len);
free(outBuf);
}
XMLRPC_RequestFree(xResponse, 0);
}
} else {
ZVAL_COPY(return_value, &data.return_data);
}
zval_ptr_dtor(&data.xmlrpc_method);
zval_ptr_dtor(&data.return_data);
if (xAnswer) {
XMLRPC_CleanupValue(xAnswer);
}
XMLRPC_RequestFree(xRequest, 1);
}
}
PHP_FUNCTION(xmlrpc_server_add_introspection_data)
{
zval *handle, *desc;
xmlrpc_server_data* server;
XMLRPC_VALUE xDesc;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "ra", &handle, &desc) == FAILURE) {
return;
}
if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) {
RETURN_FALSE;
}
xDesc = PHP_to_XMLRPC(desc);
if (xDesc) {
int retval = XMLRPC_ServerAddIntrospectionData(server->server_ptr, xDesc);
XMLRPC_CleanupValue(xDesc);
RETURN_LONG(retval);
}
RETURN_LONG(0);
}
PHP_FUNCTION(xmlrpc_parse_method_descriptions)
{
char *arg1;
size_t arg1_len;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &arg1, &arg1_len) == FAILURE) {
return;
}
if (USED_RET()) {
STRUCT_XMLRPC_ERROR err = {0};
XMLRPC_VALUE xVal = XMLRPC_IntrospectionCreateDescription(arg1, &err);
if (xVal) {
XMLRPC_to_PHP(xVal, return_value);
XMLRPC_CleanupValue(xVal);
} else {
if (err.xml_elem_error.parser_code) {
php_error_docref(NULL, E_WARNING, "xml parse error: [line %ld, column %ld, message: %s] Unable to create introspection data",
err.xml_elem_error.column, err.xml_elem_error.line, err.xml_elem_error.parser_error);
} else {
php_error_docref(NULL, E_WARNING, "Invalid xml structure. Unable to create introspection data");
}
php_error_docref(NULL, E_WARNING, "xml parse error. no method description created");
}
}
}
#define XMLRPC_TYPE_COUNT 9
#define XMLRPC_VECTOR_TYPE_COUNT 4
#define TYPE_STR_MAP_SIZE (XMLRPC_TYPE_COUNT + XMLRPC_VECTOR_TYPE_COUNT)
static const char** get_type_str_mapping(void)
{
static const char* str_mapping[TYPE_STR_MAP_SIZE];
static int first = 1;
if (first) {
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;
}
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];
}
}
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;
}
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;
}
int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype)
{
int bSuccess = FAILURE;
if (Z_TYPE_P(value) == IS_STRING) {
if (newtype == xmlrpc_base64 || newtype == xmlrpc_datetime) {
const char* typestr = xmlrpc_type_as_str(newtype, xmlrpc_vector_none);
zval type;
ZVAL_STRING(&type, typestr);
if (newtype == xmlrpc_datetime) {
XMLRPC_VALUE v = XMLRPC_CreateValueDateTime_ISO8601(NULL, Z_STRVAL_P(value));
if (v) {
time_t timestamp = (time_t) php_parse_date((char *)XMLRPC_GetValueDateTime_ISO8601(v), NULL);
if (timestamp != -1) {
zval ztimestamp;
ZVAL_LONG(&ztimestamp, timestamp);
convert_to_object(value);
if (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1, &type)) {
bSuccess = (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_VALUE_TS_ATTR, sizeof(OBJECT_VALUE_TS_ATTR) - 1, &ztimestamp) != NULL)? SUCCESS : FAILURE;
}
} else {
zval_ptr_dtor(&type);
}
XMLRPC_CleanupValue(v);
} else {
zval_ptr_dtor(&type);
}
} else {
convert_to_object(value);
bSuccess = (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1, &type) != NULL)? SUCCESS : FAILURE;
}
}
}
return bSuccess;
}
XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval* newvalue)
{
XMLRPC_VALUE_TYPE type = xmlrpc_none;
if (value) {
switch (Z_TYPE_P(value)) {
case IS_NULL:
type = xmlrpc_base64;
break;
#ifndef BOOL_AS_LONG
case IS_TRUE:
case IS_FALSE:
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:
type = xmlrpc_vector;
break;
case IS_OBJECT:
{
zval* attr;
type = xmlrpc_vector;
if ((attr = zend_hash_str_find_ind(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1)) != NULL) {
if (Z_TYPE_P(attr) == IS_STRING) {
type = xmlrpc_str_as_type(Z_STRVAL_P(attr));
}
}
break;
}
}
if (newvalue) {
zval* val;
if ((type == xmlrpc_base64 && Z_TYPE_P(value) == IS_OBJECT) || type == xmlrpc_datetime) {
if ((val = zend_hash_str_find_ind(Z_OBJPROP_P(value), OBJECT_VALUE_ATTR, sizeof(OBJECT_VALUE_ATTR) - 1)) != NULL) {
ZVAL_COPY_VALUE(newvalue, val);
}
} else {
ZVAL_COPY_VALUE(newvalue, value);
}
}
}
return type;
}
PHP_FUNCTION(xmlrpc_set_type)
{
zval *arg;
char *type;
size_t type_len;
XMLRPC_VALUE_TYPE vtype;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z/s", &arg, &type, &type_len) == FAILURE) {
return;
}
vtype = xmlrpc_str_as_type(type);
if (vtype != xmlrpc_none) {
if (set_zval_xmlrpc_type(arg, vtype) == SUCCESS) {
RETURN_TRUE;
}
} else {
zend_error(E_WARNING,"invalid type '%s' passed to xmlrpc_set_type()", type);
}
RETURN_FALSE;
}
PHP_FUNCTION(xmlrpc_get_type)
{
zval *arg;
XMLRPC_VALUE_TYPE type;
XMLRPC_VECTOR_TYPE vtype = xmlrpc_vector_none;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) {
return;
}
type = get_zval_xmlrpc_type(arg, 0);
if (type == xmlrpc_vector) {
vtype = determine_vector_type((Z_TYPE_P(arg) == IS_OBJECT) ? Z_OBJPROP_P(arg) : Z_ARRVAL_P(arg));
}
RETURN_STRING((char*) xmlrpc_type_as_str(type, vtype));
}
PHP_FUNCTION(xmlrpc_is_fault)
{
zval *arg;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "a", &arg) == FAILURE) {
return;
}
if (zend_hash_str_exists(Z_ARRVAL_P(arg), FAULT_CODE, FAULT_CODE_LEN) &&
zend_hash_str_exists(Z_ARRVAL_P(arg), FAULT_STRING, FAULT_STRING_LEN)) {
RETURN_TRUE;
}
RETURN_FALSE;
}