tony2001 Thu Jul 12 10:04:42 2007 UTC
Modified files:
/php-src/ext/xmlrpc xmlrpc-epi-php.c
Log:
fix ws, cs and folding
http://cvs.php.net/viewvc.cgi/php-src/ext/xmlrpc/xmlrpc-epi-php.c?r1=1.49&r2=1.50&diff_format=u
Index: php-src/ext/xmlrpc/xmlrpc-epi-php.c
diff -u php-src/ext/xmlrpc/xmlrpc-epi-php.c:1.49
php-src/ext/xmlrpc/xmlrpc-epi-php.c:1.50
--- php-src/ext/xmlrpc/xmlrpc-epi-php.c:1.49 Fri Jan 12 12:31:31 2007
+++ php-src/ext/xmlrpc/xmlrpc-epi-php.c Thu Jul 12 10:04:42 2007
@@ -51,7 +51,7 @@
+----------------------------------------------------------------------+
*/
-/* $Id: xmlrpc-epi-php.c,v 1.49 2007/01/12 12:31:31 tony2001 Exp $ */
+/* $Id: xmlrpc-epi-php.c,v 1.50 2007/07/12 10:04:42 tony2001 Exp $ */
/**********************************************************************
* BUGS: *
@@ -199,7 +199,7 @@
* startup / shutdown *
*********************/
-static void destroy_server_data(xmlrpc_server_data *server)
+static void destroy_server_data(xmlrpc_server_data *server) /* {{{ */
{
if (server) {
XMLRPC_ServerDestroy(server->server_ptr);
@@ -213,26 +213,28 @@
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 TSRMLS_DC)
+static void xmlrpc_server_destructor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /*
{{{ */
{
if (rsrc && rsrc->ptr) {
destroy_server_data((xmlrpc_server_data*) rsrc->ptr);
}
}
+/* }}} */
/* module init */
-PHP_MINIT_FUNCTION(xmlrpc)
+PHP_MINIT_FUNCTION(xmlrpc) /* {{{ */
{
le_xmlrpc_server =
zend_register_list_destructors_ex(xmlrpc_server_destructor, NULL, "xmlrpc
server", module_number);
-
return SUCCESS;
}
+/* }}} */
/* display info in phpinfo() */
-PHP_MINFO_FUNCTION(xmlrpc)
+PHP_MINFO_FUNCTION(xmlrpc) /* {{{ */
{
php_info_print_table_start();
php_info_print_table_row(2, "core library version",
XMLRPC_GetVersionString());
@@ -242,10 +244,11 @@
php_info_print_table_row(2, "open sourced by", "Epinions.com");
php_info_print_table_end();
}
+/* }}} */
/*******************
-* random utilities *
-*******************/
+ * 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.
@@ -273,7 +276,7 @@
#endif
-static int add_zval(zval* list, const char* id, zval** val)
+static int add_zval(zval* list, const char* id, zval** val) /* {{{ */
{
if (list && val) {
if (id) {
@@ -291,17 +294,18 @@
/* 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 *
-*************************/
+ * 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, zval* output_opts)
+static void set_output_options(php_output_options* options, zval* output_opts)
/* {{{ */
{
if (options) {
@@ -349,280 +353,270 @@
} else if (!strcmp(Z_STRVAL_PP(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;
+ options->xmlrpc_out.version =
xmlrpc_version_soap_1_1;
+ } else { /*
if(!strcmp((*val)->value.str.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));
- }
- }
-
- /* escaping options */
- if(zend_hash_find(Z_ARRVAL_P(output_opts),
- ESCAPING_KEY, ESCAPING_KEY_LEN + 1,
- (void**)&val) == SUCCESS) {
- /* multiple values allowed. check if array */
- if(Z_TYPE_PP(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;
- }
- }
- }
- 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)) {
- options->xmlrpc_out.xml_elem_opts.escaping =
xml_elem_cdata_escaping;
- }
- else if(!strcmp(Z_STRVAL_PP(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)) {
- options->xmlrpc_out.xml_elem_opts.escaping =
xml_elem_non_print_escaping;
- }
- else if(!strcmp(Z_STRVAL_PP(val),
ESCAPING_VALUE_MARKUP)) {
- options->xmlrpc_out.xml_elem_opts.escaping =
xml_elem_markup_escaping;
- }
- }
- }
- }
+ /* 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));
+ }
+ }
+
+ /* escaping options */
+ if(zend_hash_find(Z_ARRVAL_P(output_opts),
ESCAPING_KEY, ESCAPING_KEY_LEN + 1, (void**)&val) == SUCCESS) {
+ /* multiple values allowed. check if array */
+ if(Z_TYPE_PP(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;
+ }
+ }
+ } 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)) {
+
options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_cdata_escaping;
+ } else if(!strcmp(Z_STRVAL_PP(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)) {
+
options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_print_escaping;
+ } else if(!strcmp(Z_STRVAL_PP(val),
ESCAPING_VALUE_MARKUP)) {
+
options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping;
+ }
+ }
+ }
+ }
}
}
+/* }}} */
/******************
-* encode / decode *
-******************/
+ * 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)
+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);
+ 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, zval* in_val, int
depth TSRMLS_DC)
+static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int
depth TSRMLS_DC) /* {{{ */
{
- XMLRPC_VALUE xReturn = NULL;
- if(in_val) {
- zval* val = NULL;
- XMLRPC_VALUE_TYPE type = get_zval_xmlrpc_type(in_val, &val);
- if(val) {
- switch(type) {
- case xmlrpc_base64:
- if(Z_TYPE_P(val) == IS_NULL) {
- xReturn = XMLRPC_CreateValueEmpty();
+ XMLRPC_VALUE xReturn = NULL;
+ if(in_val) {
+ zval* val = NULL;
+ XMLRPC_VALUE_TYPE type = get_zval_xmlrpc_type(in_val, &val);
+ if(val) {
+ switch(type) {
+ case xmlrpc_base64:
+ if(Z_TYPE_P(val) == IS_NULL) {
+ xReturn =
XMLRPC_CreateValueEmpty();
XMLRPC_SetValueID(xReturn, key,
0);
- }
- else {
- xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL_P(val),
Z_STRLEN_P(val));
- }
- break;
- case xmlrpc_datetime:
- convert_to_string(val);
- xReturn = XMLRPC_CreateValueDateTime_ISO8601(key,
Z_STRVAL_P(val));
- break;
- case xmlrpc_boolean:
- convert_to_boolean(val);
- xReturn = XMLRPC_CreateValueBoolean(key, Z_LVAL_P(val));
- break;
- case xmlrpc_int:
- convert_to_long(val);
- xReturn = XMLRPC_CreateValueInt(key, Z_LVAL_P(val));
- break;
- case xmlrpc_double:
- convert_to_double(val);
- xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL_P(val));
- break;
- case xmlrpc_string:
- convert_to_string(val);
- xReturn = XMLRPC_CreateValueString(key, Z_STRVAL_P(val),
Z_STRLEN_P(val));
- break;
- case xmlrpc_vector:
- {
- unsigned long num_index;
- zval** pIter;
- char* my_key;
- HashTable *ht = NULL;
-
- ht = HASH_OF(val);
- if (ht && ht->nApplyCount > 1) {
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "XML-RPC
doesn't support circular references");
- return NULL;
- }
-
- convert_to_array(val);
- xReturn = XMLRPC_CreateVector(key,
determine_vector_type(Z_ARRVAL_P(val)));
-
- zend_hash_internal_pointer_reset(Z_ARRVAL_P(val));
- while(zend_hash_get_current_data(Z_ARRVAL_P(val),
(void**)&pIter) == SUCCESS) {
- int res = my_zend_hash_get_current_key(Z_ARRVAL_P(val),
&my_key, &num_index);
-
- switch (res) {
- case HASH_KEY_NON_EXISTANT:
- break;
- default:
- ht = HASH_OF(*pIter);
- if (ht) {
- ht->nApplyCount++;
- }
- if (res == HASH_KEY_IS_LONG) {
- XMLRPC_AddValueToVector(xReturn,
PHP_to_XMLRPC_worker(0, *pIter, depth++ TSRMLS_CC));
- }
- else {
- XMLRPC_AddValueToVector(xReturn,
PHP_to_XMLRPC_worker(my_key, *pIter, depth++ TSRMLS_CC));
- }
- if (ht) {
- ht->nApplyCount--;
- }
- break;
- }
- zend_hash_move_forward(Z_ARRVAL_P(val));
- }
- }
- break;
- default:
- break;
- }
- }
- }
- return xReturn;
+ } else {
+ xReturn =
XMLRPC_CreateValueBase64(key, Z_STRVAL_P(val), Z_STRLEN_P(val));
+ }
+ break;
+ case xmlrpc_datetime:
+ convert_to_string(val);
+ xReturn =
XMLRPC_CreateValueDateTime_ISO8601(key, Z_STRVAL_P(val));
+ break;
+ case xmlrpc_boolean:
+ convert_to_boolean(val);
+ xReturn =
XMLRPC_CreateValueBoolean(key, Z_LVAL_P(val));
+ break;
+ case xmlrpc_int:
+ convert_to_long(val);
+ xReturn = XMLRPC_CreateValueInt(key,
Z_LVAL_P(val));
+ break;
+ case xmlrpc_double:
+ convert_to_double(val);
+ xReturn = XMLRPC_CreateValueDouble(key,
Z_DVAL_P(val));
+ break;
+ case xmlrpc_string:
+ convert_to_string(val);
+ xReturn = XMLRPC_CreateValueString(key,
Z_STRVAL_P(val), Z_STRLEN_P(val));
+ break;
+ case xmlrpc_vector:
+ {
+ unsigned long num_index;
+ zval** pIter;
+ char* my_key;
+ HashTable *ht = NULL;
+
+ ht = HASH_OF(val);
+ if (ht && ht->nApplyCount > 1) {
+ php_error_docref(NULL
TSRMLS_CC, E_ERROR, "XML-RPC doesn't support circular references");
+ return NULL;
+ }
+
+ convert_to_array(val);
+ xReturn =
XMLRPC_CreateVector(key, determine_vector_type(Z_ARRVAL_P(val)));
+
+
zend_hash_internal_pointer_reset(Z_ARRVAL_P(val));
+
while(zend_hash_get_current_data(Z_ARRVAL_P(val), (void**)&pIter) == SUCCESS) {
+ int res =
my_zend_hash_get_current_key(Z_ARRVAL_P(val), &my_key, &num_index);
+
+ switch (res) {
+ case
HASH_KEY_NON_EXISTANT:
+ break;
+ default:
+ ht =
HASH_OF(*pIter);
+ if (ht)
{
+
ht->nApplyCount++;
+ }
+ if (res
== HASH_KEY_IS_LONG) {
+
XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(0, *pIter, depth++
TSRMLS_CC));
+ } else {
+
XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(my_key, *pIter, depth++
TSRMLS_CC));
+ }
+ if (ht)
{
+
ht->nApplyCount--;
+ }
+ break;
+ }
+
zend_hash_move_forward(Z_ARRVAL_P(val));
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ return xReturn;
}
+/* }}} */
-static XMLRPC_VALUE PHP_to_XMLRPC(zval* root_val TSRMLS_DC)
+static XMLRPC_VALUE PHP_to_XMLRPC(zval* root_val TSRMLS_DC) /* {{{ */
{
- return PHP_to_XMLRPC_worker(NULL, root_val, 0 TSRMLS_CC);
+ return PHP_to_XMLRPC_worker(NULL, root_val, 0 TSRMLS_CC);
}
+/* }}} */
/* recursively convert xmlrpc values into php values */
-static zval* XMLRPC_to_PHP(XMLRPC_VALUE el)
+static zval* XMLRPC_to_PHP(XMLRPC_VALUE el) /* {{{ */
{
- zval* elem = NULL;
- const char* pStr;
+ zval* elem = NULL;
+ const char* pStr;
- if(el) {
- XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(el);
+ 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:
- Z_TYPE_P(elem) = IS_NULL;
- 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;
- }
- break;
- case xmlrpc_int:
- Z_LVAL_P(elem) = XMLRPC_GetValueInt(el);
- Z_TYPE_P(elem) = IS_LONG;
- break;
- case xmlrpc_boolean:
- Z_LVAL_P(elem) = XMLRPC_GetValueBoolean(el);
- Z_TYPE_P(elem) = IS_BOOL;
- break;
- case xmlrpc_double:
- Z_DVAL_P(elem) = XMLRPC_GetValueDouble(el);
- Z_TYPE_P(elem) = IS_DOUBLE;
- 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;
- 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;
- }
- break;
- case xmlrpc_vector:
- array_init(elem);
- {
- XMLRPC_VALUE xIter = XMLRPC_VectorRewind(el);
-
- while( xIter ) {
- zval *val = XMLRPC_to_PHP(xIter);
- if (val) {
- add_zval(elem,
XMLRPC_GetValueID(xIter), &val);
+ MAKE_STD_ZVAL(elem); /* init. very important. spent a
frustrating day finding this out. */
+
+ switch(type) {
+ case xmlrpc_empty:
+ Z_TYPE_P(elem) = IS_NULL;
+ 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;
}
- xIter = XMLRPC_VectorNext(el);
- }
+ break;
+ case xmlrpc_int:
+ Z_LVAL_P(elem) = XMLRPC_GetValueInt(el);
+ Z_TYPE_P(elem) = IS_LONG;
+ break;
+ case xmlrpc_boolean:
+ Z_LVAL_P(elem) = XMLRPC_GetValueBoolean(el);
+ Z_TYPE_P(elem) = IS_BOOL;
+ break;
+ case xmlrpc_double:
+ Z_DVAL_P(elem) = XMLRPC_GetValueDouble(el);
+ Z_TYPE_P(elem) = IS_DOUBLE;
+ 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;
+ 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;
+ }
+ break;
+ case xmlrpc_vector:
+ array_init(elem);
+ {
+ XMLRPC_VALUE xIter =
XMLRPC_VectorRewind(el);
+
+ while( xIter ) {
+ zval *val =
XMLRPC_to_PHP(xIter);
+ if (val) {
+ add_zval(elem,
XMLRPC_GetValueID(xIter), &val);
+ }
+ xIter = XMLRPC_VectorNext(el);
+ }
+ }
+ break;
+ default:
+ break;
}
- break;
- default:
- break;
- }
- set_zval_xmlrpc_type(elem, type);
- }
- return elem;
+ set_zval_xmlrpc_type(elem, type);
+ }
+ return elem;
}
+/* }}} */
/* {{{ proto string xmlrpc_encode_request(string method, mixed params)
Generates XML for a method request */
@@ -663,7 +657,7 @@
XMLRPC_RequestFree(xRequest, 1);
}
}
-
+
if (out.xmlrpc_out.xml_elem_opts.encoding != ENCODING_DEFAULT) {
efree((char *)out.xmlrpc_out.xml_elem_opts.encoding);
}
@@ -701,34 +695,34 @@
}
/* }}} */
-
-zval* decode_request_worker (zval* xml_in, zval* encoding_in, zval*
method_name_out)
+zval* decode_request_worker (zval* xml_in, zval* encoding_in, zval*
method_name_out) /* {{{ */
{
- zval* 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(Z_STRVAL_P(encoding_in)) : ENCODING_DEFAULT;
-
- /* generate XMLRPC_REQUEST from raw xml */
- response = XMLRPC_REQUEST_FromXML(Z_STRVAL_P(xml_in), Z_STRLEN_P(xml_in),
&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) {
- zval_dtor(method_name_out);
- Z_TYPE_P(method_name_out) = IS_STRING;
- Z_STRVAL_P(method_name_out) =
estrdup(XMLRPC_RequestGetMethodName(response));
- Z_STRLEN_P(method_name_out) = strlen(Z_STRVAL_P(method_name_out));
- }
- }
-
- /* dust, sweep, and mop */
- XMLRPC_RequestFree(response, 1);
- }
- return retval;
+ zval* 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(Z_STRVAL_P(encoding_in)) : ENCODING_DEFAULT;
+
+ /* generate XMLRPC_REQUEST from raw xml */
+ response = XMLRPC_REQUEST_FromXML(Z_STRVAL_P(xml_in),
Z_STRLEN_P(xml_in), &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) {
+ zval_dtor(method_name_out);
+ Z_TYPE_P(method_name_out) = IS_STRING;
+ Z_STRVAL_P(method_name_out) =
estrdup(XMLRPC_RequestGetMethodName(response));
+ Z_STRLEN_P(method_name_out) =
strlen(Z_STRVAL_P(method_name_out));
+ }
+ }
+
+ /* dust, sweep, and mop */
+ XMLRPC_RequestFree(response, 1);
+ }
+ return retval;
}
+/* }}} */
/* {{{ proto array xmlrpc_decode_request(string xml, string& method [, string
encoding])
Decodes XML into native PHP types */
@@ -757,7 +751,6 @@
}
/* }}} */
-
/* {{{ proto array xmlrpc_decode(string xml [, string encoding])
Decodes XML into native PHP types */
PHP_FUNCTION(xmlrpc_decode)
@@ -784,10 +777,9 @@
}
/* }}} */
-
/*************************
-* server related methods *
-*************************/
+ * server related methods *
+ *************************/
/* {{{ proto resource xmlrpc_server_create(void)
Creates an xmlrpc server */
@@ -802,10 +794,10 @@
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;
@@ -847,104 +839,105 @@
}
/* }}} */
-
/* 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)
+static XMLRPC_VALUE php_xmlrpc_callback(XMLRPC_SERVER server, XMLRPC_REQUEST
xRequest, void* data) /* {{{ */
{
- xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
- zval* xmlrpc_params;
- zval* callback_params[3];
- TSRMLS_FETCH();
-
- /* 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;
+ xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
+ zval* xmlrpc_params;
+ zval* callback_params[3];
+ TSRMLS_FETCH();
+
+ /* 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 */
+ /* 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);
+ /* 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);
- pData->php_executed = 1;
+ pData->php_executed = 1;
zval_dtor(xmlrpc_params);
FREE_ZVAL(xmlrpc_params);
return NULL;
}
+/* }}} */
/* 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)
+static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void*
data) /* {{{ */
{
- zval *retval_ptr, **php_function;
- zval* callback_params[1];
- xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
- TSRMLS_FETCH();
-
- MAKE_STD_ZVAL(retval_ptr);
- Z_TYPE_P(retval_ptr) = IS_NULL;
-
- /* 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) {
-
- /* php func prototype: function string user_func($user_params) */
- if(call_user_function(CG(function_table), NULL, *php_function,
- retval_ptr, 1, callback_params TSRMLS_CC) ==
SUCCESS) {
- XMLRPC_VALUE xData;
- STRUCT_XMLRPC_ERROR err = {0};
-
- /* return value should be a string */
- convert_to_string(retval_ptr);
-
- xData =
XMLRPC_IntrospectionCreateDescription(Z_STRVAL_P(retval_ptr), &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",
Z_STRVAL_PP(php_function));
- }
- 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,
Z_STRVAL_PP(php_function));
- }
- else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to add
introspection data returned from %s()",
- Z_STRVAL_PP(php_function));
- }
- }
- }
- else {
- /* user func failed */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error calling user
introspection callback: %s()", Z_STRVAL_PP(php_function));
- }
- }
- else {
- break;
- }
+ zval *retval_ptr, **php_function;
+ zval* callback_params[1];
+ xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
+ TSRMLS_FETCH();
+
+ MAKE_STD_ZVAL(retval_ptr);
+ Z_TYPE_P(retval_ptr) = IS_NULL;
+
+ /* 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) {
+
+ /* php func prototype: function string
user_func($user_params) */
+ if(call_user_function(CG(function_table), NULL,
*php_function,
+ retval_ptr, 1, callback_params
TSRMLS_CC) == SUCCESS) {
+ XMLRPC_VALUE xData;
+ STRUCT_XMLRPC_ERROR err = {0};
+
+ /* return value should be a string */
+ convert_to_string(retval_ptr);
+
+ xData =
XMLRPC_IntrospectionCreateDescription(Z_STRVAL_P(retval_ptr), &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", Z_STRVAL_PP(php_function));
+ }
+ 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, Z_STRVAL_PP(php_function));
+ }
+ else {
+ php_error_docref(NULL
TSRMLS_CC, E_WARNING, "Unable to add introspection data returned from %s()",
+
Z_STRVAL_PP(php_function));
+ }
+ }
+ }
+ else {
+ /* user func failed */
+ php_error_docref(NULL TSRMLS_CC, E_WARNING,
"Error calling user introspection callback: %s()", Z_STRVAL_PP(php_function));
+ }
+ }
+ else {
+ break;
+ }
- zend_hash_move_forward(Z_ARRVAL_P(pData->server->introspection_map));
- }
+
zend_hash_move_forward(Z_ARRVAL_P(pData->server->introspection_map));
+ }
- /* so we don't call the same callbacks ever again */
- zend_hash_clean(Z_ARRVAL_P(pData->server->introspection_map));
+ /* so we don't call the same callbacks ever again */
+ zend_hash_clean(Z_ARRVAL_P(pData->server->introspection_map));
}
+/* }}} */
/* {{{ proto bool xmlrpc_server_register_method(resource server, string
method_name, string function)
Register a PHP function to handle method matching method_name */
@@ -980,7 +973,6 @@
}
/* }}} */
-
/* {{{ proto bool xmlrpc_server_register_introspection_callback(resource
server, string function)
Register a PHP function to generate documentation */
PHP_FUNCTION(xmlrpc_server_register_introspection_callback)
@@ -1010,9 +1002,7 @@
}
/* }}} */
-
/* this function is itchin for a re-write */
-
/* {{{ proto mixed xmlrpc_server_call_method(resource server, string xml,
mixed user_data [, array output_options])
Parses XML requests and call methods */
PHP_FUNCTION(xmlrpc_server_call_method)
@@ -1025,15 +1015,14 @@
int type;
php_output_options out;
int argc =ZEND_NUM_ARGS();
-
+
if (argc < 3 || argc > 4 || (zend_get_parameters_ex(argc, &handle,
&rawxml, &caller_params, &output_opts) != SUCCESS)) {
WRONG_PARAM_COUNT;
}
/* user output options */
if (argc == 3) {
set_output_options(&out, NULL);
- }
- else {
+ } else {
set_output_options(&out, *output_opts);
}
@@ -1058,7 +1047,7 @@
if (!methodname) {
methodname = "";
}
-
+
/* setup some data to pass to the callback function */
Z_STRVAL_P(data.xmlrpc_method) = estrdup(methodname);
Z_STRLEN_P(data.xmlrpc_method) = strlen(methodname);
@@ -1069,9 +1058,9 @@
/* check if the called method has been previous
registered */
if(zend_hash_find(Z_ARRVAL_P(server->method_map),
- Z_STRVAL_P(data.xmlrpc_method),
- Z_STRLEN_P(data.xmlrpc_method) + 1,
- (void**)&php_function) == SUCCESS) {
+ Z_STRVAL_P(data.xmlrpc_method),
+ Z_STRLEN_P(data.xmlrpc_method)
+ 1,
+ (void**)&php_function) ==
SUCCESS) {
data.php_function = *php_function;
}
@@ -1139,7 +1128,6 @@
}
/* }}} */
-
/* {{{ proto int xmlrpc_server_add_introspection_data(resource server, array
desc)
Adds introspection documentation */
PHP_FUNCTION(xmlrpc_server_add_introspection_data)
@@ -1166,7 +1154,6 @@
}
/* }}} */
-
/* {{{ proto array xmlrpc_parse_method_descriptions(string xml)
Decodes XML into a list of method descriptions */
PHP_FUNCTION(xmlrpc_parse_method_descriptions)
@@ -1195,7 +1182,7 @@
/* 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",
- err.xml_elem_error.column,
err.xml_elem_error.line, err.xml_elem_error.parser_error);
+ 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");
}
@@ -1206,188 +1193,191 @@
}
/* }}} */
-
/************
-* type data *
-************/
+ * 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(void)
+static const char** get_type_str_mapping(void) /* {{{ */
{
- 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;
+ 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* xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE
vtype) /* {{{ */
{
- const char** str_mapping = get_type_str_mapping();
+ 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];
- }
+ 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)
+XMLRPC_VALUE_TYPE xmlrpc_str_as_type(const char* str) /* {{{ */
{
- const char** str_mapping = get_type_str_mapping();
- int i;
+ 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;
+ 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)
+XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str) /* {{{ */
{
- const char** str_mapping = get_type_str_mapping();
- int i;
+ 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;
+ 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_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype)
+int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype) /* {{{ */
{
- int bSuccess = FAILURE;
- TSRMLS_FETCH();
+ 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
- */
- 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);
-
- Z_TYPE_P(type) = IS_STRING;
- Z_STRVAL_P(type) = estrdup(typestr);
- Z_STRLEN_P(type) = strlen(typestr);
-
- if(newtype == xmlrpc_datetime) {
- XMLRPC_VALUE v = XMLRPC_CreateValueDateTime_ISO8601(NULL,
value->value.str.val);
- if(v) {
- time_t timestamp = XMLRPC_GetValueDateTime(v);
- if(timestamp) {
- zval* ztimestamp;
-
- MAKE_STD_ZVAL(ztimestamp);
-
- ztimestamp->type = IS_LONG;
- ztimestamp->value.lval = 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);
- }
- }
- XMLRPC_CleanupValue(v);
- }
- }
- 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);
- }
- }
- }
-
- return bSuccess;
+ /* we only really care about strings because they can represent
+ * base64 and datetime. all other types have corresponding php types
+ */
+ 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);
+
+ Z_TYPE_P(type) = IS_STRING;
+ Z_STRVAL_P(type) = estrdup(typestr);
+ Z_STRLEN_P(type) = strlen(typestr);
+
+ if(newtype == xmlrpc_datetime) {
+ XMLRPC_VALUE v =
XMLRPC_CreateValueDateTime_ISO8601(NULL, value->value.str.val);
+ if(v) {
+ time_t timestamp =
XMLRPC_GetValueDateTime(v);
+ if(timestamp) {
+ zval* ztimestamp;
+
+ MAKE_STD_ZVAL(ztimestamp);
+
+ ztimestamp->type = IS_LONG;
+ ztimestamp->value.lval =
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);
+ }
+ }
+ XMLRPC_CleanupValue(v);
+ }
+ }
+ 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);
+ }
+ }
+ }
+
+ return bSuccess;
}
+/* }}} */
/* 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();
+ XMLRPC_VALUE_TYPE type = xmlrpc_none;
+ TSRMLS_FETCH();
- if (value) {
- switch (Z_TYPE_P(value)) {
- case IS_NULL:
- type = xmlrpc_base64;
- break;
+ if (value) {
+ switch (Z_TYPE_P(value)) {
+ 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;
+ /* Right thing to do, but it breaks some legacy
code. */
+ case IS_BOOL:
+ type = xmlrpc_boolean;
+ break;
#else
- case IS_BOOL:
+ 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:
- {
- 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));
- }
- }
- break;
- }
- }
+ 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:
+ {
+ 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));
+ }
+ }
+ break;
+ }
+ }
/* if requested, return an unmolested (magic removed) copy of
the value */
if (newvalue) {
@@ -1405,7 +1395,7 @@
return type;
}
-
+/* }}} */
/* {{{ proto bool xmlrpc_set_type(string value, string type)
Sets xmlrpc type, base64 or datetime, for a PHP string value */
@@ -1447,7 +1437,7 @@
if (type == xmlrpc_vector) {
vtype = determine_vector_type((Z_TYPE_PP(arg) == IS_OBJECT) ?
Z_OBJPROP_PP(arg) : Z_ARRVAL_PP(arg));
}
-
+
RETURN_STRING((char*) xmlrpc_type_as_str(type, vtype), 1);
}
/* }}} */
@@ -1472,7 +1462,7 @@
* a big array. Thus, we resort to this not so clever hackery.
*/
if (zend_hash_find(Z_ARRVAL_PP(arg), FAULT_CODE, FAULT_CODE_LEN
+ 1, (void**) &val) == SUCCESS &&
- zend_hash_find(Z_ARRVAL_PP(arg), FAULT_STRING,
FAULT_STRING_LEN + 1, (void**) &val) == SUCCESS) {
+ zend_hash_find(Z_ARRVAL_PP(arg), FAULT_STRING,
FAULT_STRING_LEN + 1, (void**) &val) == SUCCESS) {
RETURN_TRUE;
}
}
@@ -1481,8 +1471,6 @@
}
/* }}} */
-
-
/*
* Local variables:
* tab-width: 4
--
PHP CVS Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php
