diff options
Diffstat (limited to 'ext/xmlrpc/xmlrpc-epi-php.c')
| -rw-r--r-- | ext/xmlrpc/xmlrpc-epi-php.c | 930 |
1 files changed, 418 insertions, 512 deletions
diff --git a/ext/xmlrpc/xmlrpc-epi-php.c b/ext/xmlrpc/xmlrpc-epi-php.c index e0f3463695..b5dcee8f0d 100644 --- a/ext/xmlrpc/xmlrpc-epi-php.c +++ b/ext/xmlrpc/xmlrpc-epi-php.c @@ -1,33 +1,33 @@ /* - This file is part of, or distributed with, libXMLRPC - a C library for + 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. +/* + 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. + 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. + 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. + 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. + 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. */ @@ -35,7 +35,7 @@ /* +----------------------------------------------------------------------+ - | PHP Version 5 | + | PHP Version 7 | +----------------------------------------------------------------------+ | Copyright (c) 1997-2016 The PHP Group | +----------------------------------------------------------------------+ @@ -73,8 +73,6 @@ #include "php_xmlrpc.h" #include "xmlrpc.h" -#define PHP_EXT_VERSION "0.51" - static int le_xmlrpc_server; /* {{{ arginfo */ @@ -144,7 +142,7 @@ ZEND_END_ARG_INFO() /* }}} */ const zend_function_entry xmlrpc_functions[] = { - PHP_FE(xmlrpc_encode, arginfo_xmlrpc_encode) + 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) @@ -170,7 +168,7 @@ zend_module_entry xmlrpc_module_entry = { NULL, NULL, PHP_MINFO(xmlrpc), - PHP_EXT_VERSION, + PHP_XMLRPC_VERSION, STANDARD_MODULE_PROPERTIES }; @@ -184,8 +182,8 @@ ZEND_GET_MODULE(xmlrpc) /* per server data */ typedef struct _xmlrpc_server_data { - zval* method_map; - zval* introspection_map; + zval method_map; + zval introspection_map; XMLRPC_SERVER server_ptr; } xmlrpc_server_data; @@ -199,10 +197,10 @@ typedef struct _php_output_options { /* data passed to C callback */ typedef struct _xmlrpc_callback_data { - zval* xmlrpc_method; - zval* php_function; - zval* caller_params; - zval* return_data; + zval xmlrpc_method; + zval php_function; + zval caller_params; + zval return_data; xmlrpc_server_data* server; char php_executed; } xmlrpc_callback_data; @@ -251,10 +249,10 @@ typedef struct _xmlrpc_callback_data { /*********************** * forward declarations * ***********************/ -XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue); +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); -zval* decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval* method_name_out); +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); @@ -264,16 +262,13 @@ int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE type); * startup / shutdown * *********************/ -static void destroy_server_data(xmlrpc_server_data *server TSRMLS_DC) +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); + zval_ptr_dtor(&server->method_map); + zval_ptr_dtor(&server->introspection_map); efree(server); } @@ -281,10 +276,12 @@ static void destroy_server_data(xmlrpc_server_data *server TSRMLS_DC) /* 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 TSRMLS_DC) +static void xmlrpc_server_destructor(zend_resource *rsrc) { if (rsrc && rsrc->ptr) { - destroy_server_data((xmlrpc_server_data*) rsrc->ptr TSRMLS_CC); + rsrc->gc.refcount++; + destroy_server_data((xmlrpc_server_data*) rsrc->ptr); + rsrc->gc.refcount--; } } @@ -301,7 +298,7 @@ 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, "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"); @@ -326,40 +323,35 @@ static int add_double(zval* list, char* id, double num) { else return add_next_index_double(list, num); } -static int add_string(zval* 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_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, 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_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 int add_zval(zval* list, const char* id, zval** val) +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); - return zend_hash_index_update(Z_ARRVAL_P(list), index, (void *) val, sizeof(zval **), NULL); + zend_hash_index_update(Z_ARRVAL_P(list), index, val); } else { - return zend_hash_update(Z_ARRVAL_P(list), (char*) id, strlen(id) + 1, (void *) val, sizeof(zval **), NULL); + zend_hash_str_update(Z_ARRVAL_P(list), (char*)id, strlen(id), val); } } else { - return zend_hash_next_index_insert(Z_ARRVAL_P(list), (void *) val, sizeof(zval **), NULL); + zend_hash_next_index_insert(Z_ARRVAL_P(list), val); } } - /* what is the correct return on error? */ - return 0; } -#define my_zend_hash_get_current_key(ht, my_key, num_index) zend_hash_get_current_key(ht, my_key, num_index, 0) - - /************************* * input / output options * *************************/ @@ -369,7 +361,6 @@ static int add_zval(zval* list, const char* id, zval** val) static void set_output_options(php_output_options* options, zval* output_opts) { if (options) { - /* defaults */ options->b_php_out = 0; options->b_auto_version = 1; @@ -379,91 +370,86 @@ static void set_output_options(php_output_options* options, zval* output_opts) 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; + zval* val; /* type of output (xml/php) */ - if (zend_hash_find(Z_ARRVAL_P(output_opts), OUTPUT_TYPE_KEY, OUTPUT_TYPE_KEY_LEN + 1, (void**) &val) == SUCCESS) { - if (Z_TYPE_PP(val) == IS_STRING) { - if (!strcmp(Z_STRVAL_PP(val), OUTPUT_TYPE_VALUE_PHP)) { + 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_PP(val), OUTPUT_TYPE_VALUE_XML)) { + } else if (!strcmp(Z_STRVAL_P(val), OUTPUT_TYPE_VALUE_XML)) { options->b_php_out = 0; } } } /* verbosity of generated xml */ - if (zend_hash_find(Z_ARRVAL_P(output_opts), VERBOSITY_KEY, VERBOSITY_KEY_LEN + 1, (void**) &val) == SUCCESS) { - if (Z_TYPE_PP(val) == IS_STRING) { - if (!strcmp(Z_STRVAL_PP(val), VERBOSITY_VALUE_NO_WHITE_SPACE)) { + 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_PP(val), VERBOSITY_VALUE_NEWLINES_ONLY)) { + } 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_PP(val), VERBOSITY_VALUE_PRETTY)) { + } else if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_PRETTY)) { options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_pretty; } } } /* version of xml to output */ - if (zend_hash_find(Z_ARRVAL_P(output_opts), VERSION_KEY, VERSION_KEY_LEN + 1, (void**) &val) == SUCCESS) { - if (Z_TYPE_PP(val) == IS_STRING) { + 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_PP(val), VERSION_VALUE_XMLRPC)) { + if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_XMLRPC)) { options->xmlrpc_out.version = xmlrpc_version_1_0; - } else if (!strcmp(Z_STRVAL_PP(val), VERSION_VALUE_SIMPLE)) { + } else if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_SIMPLE)) { options->xmlrpc_out.version = xmlrpc_version_simple; - } else if (!strcmp((*val)->value.str.val, VERSION_VALUE_SOAP11)) { - options->xmlrpc_out.version = xmlrpc_version_soap_1_1; - } else { /* if(!strcmp((*val)->value.str.val, VERSION_VALUE_AUTO)) { */ - options->b_auto_version = 1; + } else if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_SOAP11)) { + options->xmlrpc_out.version = xmlrpc_version_soap_1_1; + } else { /* if(!strcmp(Z_STRVAL_P(val), VERSION_VALUE_AUTO)) { */ + options->b_auto_version = 1; } } + } /* encoding code set */ - if (zend_hash_find(Z_ARRVAL_P(output_opts), ENCODING_KEY, ENCODING_KEY_LEN + 1, (void**)&val) == SUCCESS) { - if (Z_TYPE_PP(val) == IS_STRING) { - options->xmlrpc_out.xml_elem_opts.encoding = estrdup(Z_STRVAL_PP(val)); + 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)); } } /* escaping options */ - if (zend_hash_find(Z_ARRVAL_P(output_opts), ESCAPING_KEY, ESCAPING_KEY_LEN + 1, (void**)&val) == SUCCESS) { + if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), ESCAPING_KEY, ESCAPING_KEY_LEN)) != NULL) { /* multiple values allowed. check if array */ - if (Z_TYPE_PP(val) == IS_ARRAY) { - zval** iter_val; + if (Z_TYPE_P(val) == IS_ARRAY) { + zval* iter_val; - zend_hash_internal_pointer_reset(Z_ARRVAL_PP(val)); options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_no_escaping; - while (1) { - if (zend_hash_get_current_data(Z_ARRVAL_PP(val), (void**)&iter_val) == SUCCESS) { - if (Z_TYPE_PP(iter_val) == IS_STRING && Z_STRVAL_PP(iter_val)) { - if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_CDATA)) { - options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_cdata_escaping; - } else if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_NON_ASCII)) { - options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_ascii_escaping; - } else if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_NON_PRINT)) { - options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_print_escaping; - } else if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_MARKUP)) { - options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_markup_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; } - } else { - break; } - zend_hash_move_forward(Z_ARRVAL_PP(val)); - } - /* else, check for single value */ - } else if (Z_TYPE_PP(val) == IS_STRING) { - if (!strcmp(Z_STRVAL_PP(val), ESCAPING_VALUE_CDATA)) { + } ZEND_HASH_FOREACH_END(); + /* else, check for single value */ + } 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_PP(val), ESCAPING_VALUE_NON_ASCII)) { + } 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_PP(val), ESCAPING_VALUE_NON_PRINT)) { + } 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_PP(val), ESCAPING_VALUE_MARKUP)) { + } else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_MARKUP)) { options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping; } } @@ -485,14 +471,11 @@ static void set_output_options(php_output_options* options, zval* output_opts) static XMLRPC_VECTOR_TYPE determine_vector_type (HashTable *ht) { int bArray = 0, bStruct = 0, bMixed = 0; - unsigned long num_index, last_num = 0; - 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) { + 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; @@ -502,123 +485,111 @@ static XMLRPC_VECTOR_TYPE determine_vector_type (HashTable *ht) } bArray = 1; last_num = num_index; - } else if (res == HASH_KEY_NON_EXISTENT) { - break; - } else if (res == HASH_KEY_IS_STRING) { + } else { if (bArray) { bMixed = 1; break; } bStruct = 1; } - zend_hash_move_forward(ht); - } + } ZEND_HASH_FOREACH_END(); 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, zval* in_val, int depth TSRMLS_DC) +static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int depth) { XMLRPC_VALUE xReturn = NULL; if (in_val) { - zval* val = NULL; - XMLRPC_VALUE_TYPE type = get_zval_xmlrpc_type(in_val, &val); - - if (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_P(val) == IS_NULL) { + if (Z_TYPE(val) == IS_NULL) { xReturn = XMLRPC_CreateValueEmpty(); XMLRPC_SetValueID(xReturn, key, 0); } else { - if (Z_TYPE_P(val) != IS_STRING) { - zval *newvalue; - ALLOC_INIT_ZVAL(newvalue); - MAKE_COPY_ZVAL(&val, newvalue); - convert_to_string(newvalue); - xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL_P(newvalue), Z_STRLEN_P(newvalue)); - zval_ptr_dtor(&newvalue); + 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_P(val), Z_STRLEN_P(val)); + 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_P(val)); + 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_LVAL_P(val)); + convert_to_boolean(&val); + xReturn = XMLRPC_CreateValueBoolean(key, Z_TYPE(val) == IS_TRUE); break; case xmlrpc_int: - convert_to_long(val); - xReturn = XMLRPC_CreateValueInt(key, Z_LVAL_P(val)); + 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_P(val)); + 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_P(val), Z_STRLEN_P(val)); + convert_to_string(&val); + xReturn = XMLRPC_CreateValueString(key, Z_STRVAL(val), Z_STRLEN(val)); break; case xmlrpc_vector: { - unsigned long num_index; - zval** pIter; - char* my_key; + zend_ulong num_index; + zval* pIter; + zend_string* my_key; HashTable *ht = NULL; - zval *val_arr; + zval val_arr; XMLRPC_VECTOR_TYPE vtype; - ht = HASH_OF(val); - if (ht && ht->nApplyCount > 1) { - php_error_docref(NULL TSRMLS_CC, E_ERROR, "XML-RPC doesn't support circular references"); + ht = HASH_OF(&val); + if (ht && ht->u.v.nApplyCount > 1) { + php_error_docref(NULL, E_ERROR, "XML-RPC doesn't support circular references"); return NULL; } - MAKE_STD_ZVAL(val_arr); - MAKE_COPY_ZVAL(&val, val_arr); - convert_to_array(val_arr); - - vtype = determine_vector_type(Z_ARRVAL_P(val_arr)); + 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_internal_pointer_reset(Z_ARRVAL_P(val_arr)); - while(zend_hash_get_current_data(Z_ARRVAL_P(val_arr), (void**)&pIter) == SUCCESS) { - int res = my_zend_hash_get_current_key(Z_ARRVAL_P(val_arr), &my_key, &num_index); - - switch (res) { - case HASH_KEY_NON_EXISTENT: - break; - case HASH_KEY_IS_STRING: - case HASH_KEY_IS_LONG: - ht = HASH_OF(*pIter); - if (ht) { - ht->nApplyCount++; - } - if (res == HASH_KEY_IS_LONG) { - char *num_str = NULL; - - if (vtype != xmlrpc_vector_array) { - spprintf(&num_str, 0, "%ld", num_index); - } - XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(num_str, *pIter, depth++ TSRMLS_CC)); - if (num_str) { - efree(num_str); - } - } else { - XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(my_key, *pIter, depth++ TSRMLS_CC)); - } - if (ht) { - ht->nApplyCount--; - } - break; + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL(val_arr), num_index, my_key, 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, "%ld", 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_move_forward(Z_ARRVAL_P(val_arr)); - } + } ZEND_HASH_FOREACH_END(); zval_ptr_dtor(&val_arr); } break; @@ -630,57 +601,45 @@ static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int dep return xReturn; } -static XMLRPC_VALUE PHP_to_XMLRPC(zval* root_val TSRMLS_DC) +static XMLRPC_VALUE PHP_to_XMLRPC(zval* root_val) { - return PHP_to_XMLRPC_worker(NULL, root_val, 0 TSRMLS_CC); + return PHP_to_XMLRPC_worker(NULL, root_val, 0); } /* recursively convert xmlrpc values into php values */ -static zval* XMLRPC_to_PHP(XMLRPC_VALUE el) +static void XMLRPC_to_PHP(XMLRPC_VALUE el, zval *elem) { - zval* elem = NULL; 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) { + switch (type) { case xmlrpc_empty: - Z_TYPE_P(elem) = IS_NULL; + ZVAL_NULL(elem); break; case xmlrpc_string: pStr = XMLRPC_GetValueString(el); if (pStr) { - Z_STRLEN_P(elem) = XMLRPC_GetValueStringLen(el); - Z_STRVAL_P(elem) = estrndup(pStr, Z_STRLEN_P(elem)); - Z_TYPE_P(elem) = IS_STRING; + ZVAL_STRINGL(elem, pStr, XMLRPC_GetValueStringLen(el)); } break; case xmlrpc_int: - Z_LVAL_P(elem) = XMLRPC_GetValueInt(el); - Z_TYPE_P(elem) = IS_LONG; + ZVAL_LONG(elem, XMLRPC_GetValueInt(el)); break; case xmlrpc_boolean: - Z_LVAL_P(elem) = XMLRPC_GetValueBoolean(el); - Z_TYPE_P(elem) = IS_BOOL; + ZVAL_BOOL(elem, XMLRPC_GetValueBoolean(el)); break; case xmlrpc_double: - Z_DVAL_P(elem) = XMLRPC_GetValueDouble(el); - Z_TYPE_P(elem) = IS_DOUBLE; + ZVAL_DOUBLE(elem, XMLRPC_GetValueDouble(el)); break; case xmlrpc_datetime: - Z_STRLEN_P(elem) = XMLRPC_GetValueStringLen(el); - Z_STRVAL_P(elem) = estrndup(XMLRPC_GetValueDateTime_ISO8601(el), Z_STRLEN_P(elem)); - Z_TYPE_P(elem) = IS_STRING; + ZVAL_STRINGL(elem, XMLRPC_GetValueDateTime_ISO8601(el), XMLRPC_GetValueStringLen(el)); break; case xmlrpc_base64: pStr = XMLRPC_GetValueBase64(el); if (pStr) { - Z_STRLEN_P(elem) = XMLRPC_GetValueStringLen(el); - Z_STRVAL_P(elem) = estrndup(pStr, Z_STRLEN_P(elem)); - Z_TYPE_P(elem) = IS_STRING; + ZVAL_STRINGL(elem, pStr, XMLRPC_GetValueStringLen(el)); } break; case xmlrpc_vector: @@ -689,8 +648,10 @@ static zval* XMLRPC_to_PHP(XMLRPC_VALUE el) XMLRPC_VALUE xIter = XMLRPC_VectorRewind(el); while( xIter ) { - zval *val = XMLRPC_to_PHP(xIter); - if (val) { + 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); @@ -702,7 +663,6 @@ static zval* XMLRPC_to_PHP(XMLRPC_VALUE el) } set_zval_xmlrpc_type(elem, type); } - return elem; } /* {{{ proto string xmlrpc_encode_request(string method, mixed params [, array output_options]) @@ -713,16 +673,16 @@ PHP_FUNCTION(xmlrpc_encode_request) char *outBuf; zval *vals, *out_opts = NULL; char *method = NULL; - int method_len; + size_t method_len; php_output_options out; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!z|a", &method, &method_len, &vals, &out_opts) == FAILURE) { + 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 (return_value_used) { + if (USED_RET()) { xRequest = XMLRPC_RequestNew(); if (xRequest) { @@ -734,18 +694,18 @@ PHP_FUNCTION(xmlrpc_encode_request) XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_call); } if (Z_TYPE_P(vals) != IS_NULL) { - XMLRPC_RequestSetData(xRequest, PHP_to_XMLRPC(vals TSRMLS_CC)); + XMLRPC_RequestSetData(xRequest, PHP_to_XMLRPC(vals)); } outBuf = XMLRPC_REQUEST_ToXML(xRequest, 0); if (outBuf) { - RETVAL_STRING(outBuf, 1); + 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); } @@ -757,23 +717,23 @@ PHP_FUNCTION(xmlrpc_encode_request) PHP_FUNCTION(xmlrpc_encode) { XMLRPC_VALUE xOut = NULL; - zval **arg1; + zval *arg1; char *outBuf; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg1) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg1) == FAILURE) { return; } - if (return_value_used) { + if (USED_RET()) { /* convert native php type to xmlrpc type */ - xOut = PHP_to_XMLRPC(*arg1 TSRMLS_CC); + 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); + RETVAL_STRING(outBuf); free(outBuf); } /* cleanup */ @@ -783,9 +743,8 @@ PHP_FUNCTION(xmlrpc_encode) } /* }}} */ -zval* decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval* method_name_out) /* {{{ */ +void decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval* method_name_out, zval *retval) /* {{{ */ { - zval* retval = NULL; XMLRPC_REQUEST response; STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS opts = {{0}}; const char *method_name; @@ -794,20 +753,19 @@ zval* decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zva /* generate XMLRPC_REQUEST from raw xml */ response = XMLRPC_REQUEST_FromXML(xml_in, xml_in_len, &opts); if (response) { + ZVAL_NULL(retval); /* convert xmlrpc data to native php types */ - retval = XMLRPC_to_PHP(XMLRPC_RequestGetData(response)); + 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_dtor(method_name_out); - Z_TYPE_P(method_name_out) = IS_STRING; - Z_STRVAL_P(method_name_out) = estrdup(method_name); - Z_STRLEN_P(method_name_out) = strlen(Z_STRVAL_P(method_name_out)); - } else if (retval) { - zval_ptr_dtor(&retval); - retval = NULL; + zval_ptr_dtor(method_name_out); + ZVAL_STRING(method_name_out, method_name); + } else { + zval_ptr_dtor(retval); + ZVAL_NULL(retval); } } } @@ -815,7 +773,6 @@ zval* decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zva /* dust, sweep, and mop */ XMLRPC_RequestFree(response, 1); } - return retval; } /* }}} */ @@ -824,20 +781,15 @@ zval* decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zva PHP_FUNCTION(xmlrpc_decode_request) { char *xml, *encoding = NULL; - zval **method; - int xml_len, encoding_len = 0; + zval *method; + size_t xml_len, encoding_len = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) { return; } - - if (return_value_used) { - zval* retval = decode_request_worker(xml, xml_len, encoding_len ? encoding : NULL, *method); - if (retval) { - *return_value = *retval; - FREE_ZVAL(retval); - } + if (USED_RET()) { + decode_request_worker(xml, xml_len, encoding_len ? encoding : NULL, method, return_value); } } /* }}} */ @@ -847,18 +799,14 @@ PHP_FUNCTION(xmlrpc_decode_request) PHP_FUNCTION(xmlrpc_decode) { char *arg1, *arg2 = NULL; - int arg1_len, arg2_len = 0; + size_t arg1_len, arg2_len = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &arg1, &arg1_len, &arg2, &arg2_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", &arg1, &arg1_len, &arg2, &arg2_len) == FAILURE) { return; } - if (return_value_used) { - zval* retval = decode_request_worker(arg1, arg1_len, arg2_len ? arg2 : NULL, NULL); - if (retval) { - *return_value = *retval; - FREE_ZVAL(retval); - } + if (USED_RET()) { + decode_request_worker(arg1, arg1_len, arg2_len ? arg2 : NULL, NULL, return_value); } } /* }}} */ @@ -875,24 +823,18 @@ PHP_FUNCTION(xmlrpc_server_create) return; } - if (return_value_used) { - zval *method_map, *introspection_map; + if (USED_RET()) { xmlrpc_server_data *server = emalloc(sizeof(xmlrpc_server_data)); - MAKE_STD_ZVAL(method_map); - MAKE_STD_ZVAL(introspection_map); - - array_init(method_map); - array_init(introspection_map); - + /* allocate server data. free'd in destroy_server_data() */ - server->method_map = method_map; - server->introspection_map = introspection_map; + array_init(&server->method_map); + array_init(&server->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, le_xmlrpc_server); + RETURN_RES(zend_register_resource(server, le_xmlrpc_server)); } } /* }}} */ @@ -902,68 +844,62 @@ PHP_FUNCTION(xmlrpc_server_create) PHP_FUNCTION(xmlrpc_server_destroy) { zval *arg1; - int bSuccess = FAILURE, type; + int bSuccess = FAILURE; xmlrpc_server_data *server; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &arg1) == FAILURE) { return; } - server = zend_list_find(Z_LVAL_P(arg1), &type); - - if (server && type == le_xmlrpc_server) { - bSuccess = zend_list_delete(Z_LVAL_P(arg1)); - - /* called by hashtable destructor - * destroy_server_data(server); - */ + if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(arg1), "xmlrpc server", le_xmlrpc_server)) == NULL) { + RETURN_FALSE; } - RETVAL_LONG(bSuccess == SUCCESS); + + bSuccess = zend_list_close(Z_RES_P(arg1)); + /* called by hashtable destructor + * destroy_server_data(server); + */ + RETURN_BOOL(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) /* {{{ */ { xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data; - zval** php_function; - zval* xmlrpc_params; - zval* callback_params[3]; - TSRMLS_FETCH(); + zval* php_function; + zval xmlrpc_params; + zval callback_params[3]; - zval_dtor(pData->xmlrpc_method); - zval_dtor(pData->return_data); + zval_ptr_dtor(&pData->xmlrpc_method); + zval_ptr_dtor(&pData->return_data); /* convert xmlrpc to native php types */ - ZVAL_STRING(pData->xmlrpc_method, XMLRPC_RequestGetMethodName(xRequest), 1); - xmlrpc_params = XMLRPC_to_PHP(XMLRPC_RequestGetData(xRequest)); - - /* check if the called method has been previous registered */ - if(zend_hash_find(Z_ARRVAL_P(pData->server->method_map), - Z_STRVAL_P(pData->xmlrpc_method), - Z_STRLEN_P(pData->xmlrpc_method) + 1, - (void**)&php_function) == SUCCESS) { + ZVAL_STRING(&pData->xmlrpc_method, XMLRPC_RequestGetMethodName(xRequest)); + XMLRPC_to_PHP(XMLRPC_RequestGetData(xRequest), &xmlrpc_params); - pData->php_function = *php_function; + /* check if the called method has been previous registered */ + 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); } /* setup data hoojum */ - callback_params[0] = pData->xmlrpc_method; - callback_params[1] = xmlrpc_params; - callback_params[2] = pData->caller_params; + 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); /* 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 TSRMLS_CC); + 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 TSRMLS_CC); + return PHP_to_XMLRPC(&pData->return_data); } /* }}} */ @@ -972,61 +908,53 @@ static XMLRPC_VALUE php_xmlrpc_callback(XMLRPC_SERVER server, XMLRPC_REQUEST xRe */ static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data) /* {{{ */ { - zval retval, **php_function; - zval *callback_params[1]; - char *php_function_name; + zval retval, *php_function; + zval callback_params[1]; + zend_string *php_function_name; xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data; - TSRMLS_FETCH(); /* setup data hoojum */ - callback_params[0] = pData->caller_params; - - /* loop through and call all registered callbacks */ - zend_hash_internal_pointer_reset(Z_ARRVAL_P(pData->server->introspection_map)); - while (1) { - if (zend_hash_get_current_data(Z_ARRVAL_P(pData->server->introspection_map), (void**)&php_function) == SUCCESS) { - if (zend_is_callable(*php_function, 0, &php_function_name TSRMLS_CC)) { - /* php func prototype: function string user_func($user_params) */ - if (call_user_function(CG(function_table), NULL, *php_function, &retval, 1, callback_params TSRMLS_CC) == SUCCESS) { - XMLRPC_VALUE xData; - STRUCT_XMLRPC_ERROR err = {0}; - - /* return value should be a string */ - convert_to_string(&retval); - - xData = XMLRPC_IntrospectionCreateDescription(Z_STRVAL(retval), &err); - - if (xData) { - if (!XMLRPC_ServerAddIntrospectionData(server, xData)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to add introspection data returned from %s(), improper element structure", php_function_name); - } - XMLRPC_CleanupValue(xData); - } else { - /* could not create description */ - if (err.xml_elem_error.parser_code) { - php_error_docref(NULL TSRMLS_CC, 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, php_function_name); - } else { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to add introspection data returned from %s()", php_function_name); - } + 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)) { + /* php func prototype: function string user_func($user_params) */ + if (call_user_function(CG(function_table), NULL, php_function, &retval, 1, callback_params) == SUCCESS) { + XMLRPC_VALUE xData; + STRUCT_XMLRPC_ERROR err = {0}; + + /* return value should be a string */ + 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)); } - zval_dtor(&retval); + XMLRPC_CleanupValue(xData); } else { - /* user func failed */ - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error calling user introspection callback: %s()", php_function_name); + /* could not create description */ + 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 TSRMLS_CC, E_WARNING, "Invalid callback '%s' passed", php_function_name); + /* user func failed */ + php_error_docref(NULL, E_WARNING, "Error calling user introspection callback: %s()", ZSTR_VAL(php_function_name)); } - efree(php_function_name); } else { - break; + php_error_docref(NULL, E_WARNING, "Invalid callback '%s' passed", ZSTR_VAL(php_function_name)); } - zend_hash_move_forward(Z_ARRVAL_P(pData->server->introspection_map)); - } - + zend_string_release(php_function_name); + } ZEND_HASH_FOREACH_END(); + /* so we don't call the same callbacks ever again */ - zend_hash_clean(Z_ARRVAL_P(pData->server->introspection_map)); + zend_hash_clean(Z_ARRVAL(pData->server->introspection_map)); } /* }}} */ @@ -1035,33 +963,32 @@ static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data) PHP_FUNCTION(xmlrpc_server_register_method) { char *method_key; - int method_key_len; - zval *handle, *method_name_save, **method_name; - int type; + size_t method_key_len; + zval *handle, *method_name; xmlrpc_server_data* server; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ", &handle, &method_key, &method_key_len, &method_name) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz", &handle, &method_key, &method_key_len, &method_name) == FAILURE) { return; } - server = zend_list_find(Z_LVAL_P(handle), &type); - - if (type == 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, php_xmlrpc_callback)) { - /* save for later use */ - ALLOC_ZVAL(method_name_save); - MAKE_COPY_ZVAL(method_name, method_name_save); + if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) { + RETURN_FALSE; + } - /* register our php method */ - add_zval(server->method_map, method_key, &method_name_save); + /* 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, php_xmlrpc_callback)) { + /* save for later use */ - RETURN_BOOL(1); + if (Z_REFCOUNTED_P(method_name)) { + Z_ADDREF_P(method_name); } + /* register our php method */ + add_zval(&server->method_map, method_key, method_name); + + RETURN_TRUE; } - RETURN_BOOL(0); } /* }}} */ @@ -1069,27 +996,24 @@ PHP_FUNCTION(xmlrpc_server_register_method) Register a PHP function to generate documentation */ PHP_FUNCTION(xmlrpc_server_register_introspection_callback) { - zval **method_name, *handle, *method_name_save; - int type; + zval *method_name, *handle; xmlrpc_server_data* server; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &handle, &method_name) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz", &handle, &method_name) == FAILURE) { return; } - server = zend_list_find(Z_LVAL_P(handle), &type); - - if (type == le_xmlrpc_server) { - /* save for later use */ - ALLOC_ZVAL(method_name_save); - MAKE_COPY_ZVAL(method_name, method_name_save); - - /* register our php method */ - add_zval(server->introspection_map, NULL, &method_name_save); + if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) { + RETURN_FALSE; + } - RETURN_BOOL(1); + if (Z_REFCOUNTED_P(method_name)) { + Z_ADDREF_P(method_name); } - RETURN_BOOL(0); + /* register our php method */ + add_zval(&server->introspection_map, NULL, method_name); + + RETURN_TRUE; } /* }}} */ @@ -1099,17 +1023,17 @@ PHP_FUNCTION(xmlrpc_server_register_introspection_callback) Parses XML requests and call methods */ PHP_FUNCTION(xmlrpc_server_call_method) { - xmlrpc_callback_data data = {0}; 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; + zval *caller_params, *handle, *output_opts = NULL; char *rawxml; - int rawxml_len, type; + size_t rawxml_len; php_output_options out; - int argc =ZEND_NUM_ARGS(); - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ|a", &handle, &rawxml, &rawxml_len, &caller_params, &output_opts) != SUCCESS) { + int argc = ZEND_NUM_ARGS(); + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz|a", &handle, &rawxml, &rawxml_len, &caller_params, &output_opts) != SUCCESS) { return; } /* user output options */ @@ -1119,87 +1043,82 @@ PHP_FUNCTION(xmlrpc_server_call_method) set_output_options(&out, output_opts); } - server = zend_list_find(Z_LVAL_P(handle), &type); + if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) { + RETURN_FALSE; + } + + /* 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); - if (type == 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, rawxml_len, &input_opts); - /* generate an XMLRPC_REQUEST from the raw xml input */ - 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); /* init. very important. spent a frustrating day finding this out. */ + ZVAL_NULL(&data.return_data); + ZVAL_NULL(&data.return_data); /* in case value is never init'd, we don't dtor to think it is a string or something */ + ZVAL_NULL(&data.xmlrpc_method); - if (xRequest) { - const char* methodname = XMLRPC_RequestGetMethodName(xRequest); - 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); - Z_TYPE_P(data.return_data) = IS_NULL; /* in case value is never init'd, we don't dtor to think it is a string or something */ - Z_TYPE_P(data.xmlrpc_method) = IS_NULL; - - /* setup some data to pass to the callback function */ - data.caller_params = *caller_params; - data.php_executed = 0; - data.server = server; - - /* 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 && 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 && !out.b_php_out && !xAnswer) { - xAnswer = PHP_to_XMLRPC(data.return_data TSRMLS_CC); - } + /* setup some data to pass to the callback function */ + ZVAL_COPY_VALUE(&data.caller_params, caller_params); + data.php_executed = 0; + data.server = server; - /* 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; - - /* automagically determine output serialization type from request type */ - if (out.b_auto_version) { - XMLRPC_REQUEST_OUTPUT_OPTIONS opts = XMLRPC_RequestGetOutputOptions(xRequest); - if (opts) { - out.xmlrpc_out.version = opts->version; - } - } - /* set some required request hoojum */ - XMLRPC_RequestSetOutputOptions(xResponse, &out.xmlrpc_out); - XMLRPC_RequestSetRequestType(xResponse, xmlrpc_request_response); - XMLRPC_RequestSetData(xResponse, xAnswer); - XMLRPC_RequestSetMethodName(xResponse, methodname); - - /* generate xml */ - outBuf = XMLRPC_REQUEST_ToXML(xResponse, &buf_len); - if (outBuf) { - RETVAL_STRINGL(outBuf, buf_len, 1); - free(outBuf); + /* 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 && 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); + } + + /* 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; + + /* automagically determine output serialization type from request type */ + if (out.b_auto_version) { + XMLRPC_REQUEST_OUTPUT_OPTIONS opts = XMLRPC_RequestGetOutputOptions(xRequest); + if (opts) { + out.xmlrpc_out.version = opts->version; } - /* cleanup after ourselves. what a sty! */ - XMLRPC_RequestFree(xResponse, 0); } - } else { /* or as native php types? */ - *return_value = *data.return_data; - zval_copy_ctor(return_value); + /* set some required request hoojum */ + XMLRPC_RequestSetOutputOptions(xResponse, &out.xmlrpc_out); + XMLRPC_RequestSetRequestType(xResponse, xmlrpc_request_response); + XMLRPC_RequestSetData(xResponse, xAnswer); + XMLRPC_RequestSetMethodName(xResponse, methodname); + + /* generate xml */ + outBuf = XMLRPC_REQUEST_ToXML(xResponse, &buf_len); + if (outBuf) { + RETVAL_STRINGL(outBuf, buf_len); + free(outBuf); + } + /* cleanup after ourselves. what a sty! */ + XMLRPC_RequestFree(xResponse, 0); } + } else { /* or as native php types? */ + ZVAL_COPY(return_value, &data.return_data); + } - /* cleanup after ourselves. what a sty! */ - zval_ptr_dtor(&data.xmlrpc_method); - - zval_dtor(data.return_data); - FREE_ZVAL(data.return_data); + /* cleanup after ourselves. what a sty! */ + zval_ptr_dtor(&data.xmlrpc_method); + zval_ptr_dtor(&data.return_data); - if (xAnswer) { - XMLRPC_CleanupValue(xAnswer); - } - - XMLRPC_RequestFree(xRequest, 1); + if (xAnswer) { + XMLRPC_CleanupValue(xAnswer); } + + XMLRPC_RequestFree(xRequest, 1); } } /* }}} */ @@ -1209,22 +1128,22 @@ PHP_FUNCTION(xmlrpc_server_call_method) PHP_FUNCTION(xmlrpc_server_add_introspection_data) { zval *handle, *desc; - int type; xmlrpc_server_data* server; + XMLRPC_VALUE xDesc; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &handle, &desc) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "ra", &handle, &desc) == FAILURE) { return; } - server = zend_list_find(Z_LVAL_P(handle), &type); + if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) { + RETURN_FALSE; + } - if (type == le_xmlrpc_server) { - XMLRPC_VALUE xDesc = PHP_to_XMLRPC(desc TSRMLS_CC); - if (xDesc) { - int retval = XMLRPC_ServerAddIntrospectionData(server->server_ptr, xDesc); - XMLRPC_CleanupValue(xDesc); - RETURN_LONG(retval); - } + xDesc = PHP_to_XMLRPC(desc); + if (xDesc) { + int retval = XMLRPC_ServerAddIntrospectionData(server->server_ptr, xDesc); + XMLRPC_CleanupValue(xDesc); + RETURN_LONG(retval); } RETURN_LONG(0); } @@ -1234,35 +1153,30 @@ PHP_FUNCTION(xmlrpc_server_add_introspection_data) Decodes XML into a list of method descriptions */ PHP_FUNCTION(xmlrpc_parse_method_descriptions) { - zval *retval; char *arg1; - int arg1_len; + size_t arg1_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg1, &arg1_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &arg1, &arg1_len) == FAILURE) { return; } - if (return_value_used) { + if (USED_RET()) { STRUCT_XMLRPC_ERROR err = {0}; XMLRPC_VALUE xVal = XMLRPC_IntrospectionCreateDescription(arg1, &err); if (xVal) { - retval = XMLRPC_to_PHP(xVal); - - if (retval) { - RETVAL_ZVAL(retval, 1, 1); - } + XMLRPC_to_PHP(xVal, return_value); /* dust, sweep, and mop */ XMLRPC_CleanupValue(xVal); } else { /* could not create description */ if (err.xml_elem_error.parser_code) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "xml parse error: [line %ld, column %ld, message: %s] Unable to create introspection data", + 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 TSRMLS_CC, E_WARNING, "Invalid xml structure. Unable to create introspection data"); + php_error_docref(NULL, E_WARNING, "Invalid xml structure. Unable to create introspection data"); } - php_error_docref(NULL TSRMLS_CC, E_WARNING, "xml parse error. no method description created"); + php_error_docref(NULL, E_WARNING, "xml parse error. no method description created"); } } } @@ -1349,14 +1263,13 @@ XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str) /* {{{ */ } /* }}} */ -/* set a given value to a particular type. +/* 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_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype) /* {{{ */ { int bSuccess = FAILURE; - TSRMLS_FETCH(); /* we only really care about strings because they can represent * base64 and datetime. all other types have corresponding php types @@ -1364,29 +1277,22 @@ int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype) /* {{{ */ 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; - - MAKE_STD_ZVAL(type); + zval type; - Z_TYPE_P(type) = IS_STRING; - Z_STRVAL_P(type) = estrdup(typestr); - Z_STRLEN_P(type) = strlen(typestr); + ZVAL_STRING(&type, typestr); if (newtype == xmlrpc_datetime) { - XMLRPC_VALUE v = XMLRPC_CreateValueDateTime_ISO8601(NULL, value->value.str.val); + 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; - - MAKE_STD_ZVAL(ztimestamp); + zval ztimestamp; - ztimestamp->type = IS_LONG; - ztimestamp->value.lval = timestamp; + ZVAL_LONG(&ztimestamp, timestamp); convert_to_object(value); - if (SUCCESS == zend_hash_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR), (void *) &type, sizeof(zval *), NULL)) { - bSuccess = zend_hash_update(Z_OBJPROP_P(value), OBJECT_VALUE_TS_ATTR, sizeof(OBJECT_VALUE_TS_ATTR), (void *) &ztimestamp, sizeof(zval *), NULL); + 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); @@ -1397,7 +1303,7 @@ int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype) /* {{{ */ } } else { convert_to_object(value); - bSuccess = zend_hash_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR), (void *) &type, sizeof(zval *), NULL); + bSuccess = (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1, &type) != NULL)? SUCCESS : FAILURE; } } } @@ -1407,10 +1313,9 @@ int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype) /* {{{ */ /* }}} */ /* return xmlrpc type of a php value */ -XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue) /* {{{ */ +XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval* newvalue) /* {{{ */ { XMLRPC_VALUE_TYPE type = xmlrpc_none; - TSRMLS_FETCH(); if (value) { switch (Z_TYPE_P(value)) { @@ -1420,7 +1325,8 @@ XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue) /* {{{ */ #ifndef BOOL_AS_LONG /* Right thing to do, but it breaks some legacy code. */ - case IS_BOOL: + case IS_TRUE: + case IS_FALSE: type = xmlrpc_boolean; break; #else @@ -1444,12 +1350,12 @@ XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue) /* {{{ */ break; case IS_OBJECT: { - zval** attr; + zval* attr; type = xmlrpc_vector; - if (zend_hash_find(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR), (void**) &attr) == SUCCESS) { - if (Z_TYPE_PP(attr) == IS_STRING) { - type = xmlrpc_str_as_type(Z_STRVAL_PP(attr)); + if ((attr = zend_hash_str_find(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; @@ -1458,14 +1364,14 @@ XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue) /* {{{ */ /* if requested, return an unmolested (magic removed) copy of the value */ if (newvalue) { - zval** val; + zval* val; if ((type == xmlrpc_base64 && Z_TYPE_P(value) == IS_OBJECT) || type == xmlrpc_datetime) { - if (zend_hash_find(Z_OBJPROP_P(value), OBJECT_VALUE_ATTR, sizeof(OBJECT_VALUE_ATTR), (void**) &val) == SUCCESS) { - *newvalue = *val; + if ((val = zend_hash_str_find(Z_OBJPROP_P(value), OBJECT_VALUE_ATTR, sizeof(OBJECT_VALUE_ATTR) - 1)) != NULL) { + ZVAL_COPY_VALUE(newvalue, val); } } else { - *newvalue = value; + ZVAL_COPY_VALUE(newvalue, value); } } } @@ -1478,18 +1384,18 @@ XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue) /* {{{ */ Sets xmlrpc type, base64 or datetime, for a PHP string value */ PHP_FUNCTION(xmlrpc_set_type) { - zval **arg; + zval *arg; char *type; - int type_len; + size_t type_len; XMLRPC_VALUE_TYPE vtype; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &arg, &type, &type_len) == FAILURE) { + 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) { + if (set_zval_xmlrpc_type(arg, vtype) == SUCCESS) { RETURN_TRUE; } } else { @@ -1503,30 +1409,30 @@ PHP_FUNCTION(xmlrpc_set_type) Gets xmlrpc type for a PHP value. Especially useful for base64 and datetime strings */ PHP_FUNCTION(xmlrpc_get_type) { - zval **arg; + zval *arg; XMLRPC_VALUE_TYPE type; XMLRPC_VECTOR_TYPE vtype = xmlrpc_vector_none; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) { return; } - type = get_zval_xmlrpc_type(*arg, 0); + type = get_zval_xmlrpc_type(arg, 0); if (type == xmlrpc_vector) { - vtype = determine_vector_type((Z_TYPE_PP(arg) == IS_OBJECT) ? Z_OBJPROP_PP(arg) : Z_ARRVAL_PP(arg)); + 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), 1); + + RETURN_STRING((char*) xmlrpc_type_as_str(type, vtype)); } /* }}} */ -/* {{{ proto bool xmlrpc_is_fault(array) +/* {{{ proto bool xmlrpc_is_fault(array arg) Determines if an array value represents an XMLRPC fault. */ PHP_FUNCTION(xmlrpc_is_fault) { - zval *arg, **val; + zval *arg; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &arg) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "a", &arg) == FAILURE) { return; } @@ -1536,8 +1442,8 @@ PHP_FUNCTION(xmlrpc_is_fault) * array, which is rather expensive, especially if it was * a big array. Thus, we resort to this not so clever hackery. */ - if (zend_hash_find(Z_ARRVAL_P(arg), FAULT_CODE, FAULT_CODE_LEN + 1, (void**) &val) == SUCCESS && - zend_hash_find(Z_ARRVAL_P(arg), FAULT_STRING, FAULT_STRING_LEN + 1, (void**) &val) == SUCCESS) { + 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; } |