Imported Upstream version 5.3.0RC1upstream/5.3.0_RC1upstream/5.3.0RC1

7 files changed, 384 insertions, 334 deletions

diff --git a/ext/xmlrpc/config.w32 b/ext/xmlrpc/config.w32
index 400144671..250ba5662 100644
--- a/ext/xmlrpc/config.w32
+++ b/ext/xmlrpc/config.w32
@@ -1,14 +1,20 @@
-// $Id: config.w32,v 1.2 2003/12/22 13:16:42 wez Exp $
+// $Id: config.w32,v 1.2.8.2 2008/07/06 16:52:59 pajoye Exp $
 // vim:ft=javascript
 
 ARG_WITH("xmlrpc", "XMLRPC-EPI support", "no");
 
 if (PHP_XMLRPC != "no") {
-	CHECK_HEADER_ADD_INCLUDE("xmlrpc.h", "CFLAGS_XMLRPC", configure_module_dirname + "/libxmlrpc");
-	EXTENSION('xmlrpc', 'xmlrpc-epi-php.c', PHP_XMLRPC_SHARED, "-DVERSION=\"0.50\"");
-	ADD_SOURCES(configure_module_dirname + "/libxmlrpc", "base64.c simplestring.c xml_to_dandarpc.c \
-	xmlrpc_introspection.c encodings.c system_methods.c xml_to_xmlrpc.c \
-	queue.c xml_element.c xmlrpc.c xml_to_soap.c", "xmlrpc");
-	ADD_EXTENSION_DEP('xmlrpc', 'libxml');
+	if (CHECK_HEADER_ADD_INCLUDE("xmlrpc.h", "CFLAGS_XMLRPC", configure_module_dirname + "/libxmlrpc")
+		&& CHECK_HEADER_ADD_INCLUDE("iconv.h", "CFLAGS")
+		&& ADD_EXTENSION_DEP('xmlrpc', 'libxml')) {
+		EXTENSION('xmlrpc', 'xmlrpc-epi-php.c', PHP_XMLRPC_SHARED, "-DVERSION=\"0.50\"");
+		ADD_SOURCES(configure_module_dirname + "/libxmlrpc", "base64.c simplestring.c xml_to_dandarpc.c \
+		xmlrpc_introspection.c encodings.c system_methods.c xml_to_xmlrpc.c \
+		queue.c xml_element.c xmlrpc.c xml_to_soap.c", "xmlrpc");
+
+	} else {
+		WARNING("xmlrpc support can't be enabled, libraries or headers are missing")
+		PHP_XMLRPC = "no";
+	}
 }
 
diff --git a/ext/xmlrpc/libxmlrpc/xml_element.c b/ext/xmlrpc/libxmlrpc/xml_element.c
index faf76714e..f65ee5a7e 100644
--- a/ext/xmlrpc/libxmlrpc/xml_element.c
+++ b/ext/xmlrpc/libxmlrpc/xml_element.c
@@ -31,7 +31,7 @@
 */
 
 
-static const char rcsid[] = "#(@) $Id: xml_element.c,v 1.9.4.3 2008/12/17 21:45:31 iliaa Exp $";
+static const char rcsid[] = "#(@) $Id: xml_element.c,v 1.9.4.1.2.2 2008/12/17 00:30:27 iliaa Exp $";
 
 
 
@@ -44,12 +44,14 @@ static const char rcsid[] = "#(@) $Id: xml_element.c,v 1.9.4.3 2008/12/17 21:45:
  *   06/2000
  * HISTORY
  *   $Log: xml_element.c,v $
- *   Revision 1.9.4.3  2008/12/17 21:45:31  iliaa
- *   MFB: remove fprintf usage
+ *   Revision 1.9.4.1.2.2  2008/12/17 00:30:27  iliaa
  *
- *   Revision 1.9.4.2  2008/12/17 00:30:48  iliaa
+ *   Removed unused variable
  *
- *   MFH: removed unused var
+ *   Revision 1.9.4.1.2.1  2008/12/09 17:22:12  iliaa
+ *
+ *   MFH: Fixed bug #46746 (xmlrpc_decode_request outputs non-suppressable error
+ *   when given bad data).
  *
  *   Revision 1.9.4.1  2006/07/30 11:34:02  tony2001
  *   MFH: fix compile warnings (#38257)
@@ -385,7 +387,7 @@ static void xml_element_serialize(xml_element *el, int (*fptr)(void *data, const
    depth++;
 
    if(!el) {
-/*      fprintf(stderr, "Nothing to write\n"); */
+      /* fprintf(stderr, "Nothing to write\n"); */
       return;
    }
    if(!options) {
diff --git a/ext/xmlrpc/libxmlrpc/xml_to_soap.c b/ext/xmlrpc/libxmlrpc/xml_to_soap.c
index 07c57087f..664e8b77b 100644
--- a/ext/xmlrpc/libxmlrpc/xml_to_soap.c
+++ b/ext/xmlrpc/libxmlrpc/xml_to_soap.c
@@ -379,7 +379,7 @@ XMLRPC_VALUE xml_element_to_SOAP_REQUEST_worker(XMLRPC_REQUEST request,
 			else if (!strcmp(type, TOKEN_ARRAY) || arrayType != NULL) {
 				/* determine magic associated with soap array type.
 				   this is passed down as we recurse, so our children have access to the info. */
-				ai = parse_array_type_info(arrayType);	// alloc'ed ai free'd below.
+				ai = parse_array_type_info(arrayType);	/* alloc'ed ai free'd below. */
 				XMLRPC_SetIsVector(xCurrent, xmlrpc_vector_array);
 			}
 			else {
diff --git a/ext/xmlrpc/libxmlrpc/xmlrpc.c b/ext/xmlrpc/libxmlrpc/xmlrpc.c
index 7533016bf..926ecfaa4 100644
--- a/ext/xmlrpc/libxmlrpc/xmlrpc.c
+++ b/ext/xmlrpc/libxmlrpc/xmlrpc.c
@@ -31,7 +31,7 @@
 */
 
 
-static const char rcsid[] = "#(@) $Id: xmlrpc.c,v 1.8.4.5 2008/12/17 21:45:31 iliaa Exp $";
+static const char rcsid[] = "#(@) $Id: xmlrpc.c,v 1.8.4.3.2.2 2008/12/09 17:22:12 iliaa Exp $";
 
 
 /****h* ABOUT/xmlrpc
@@ -43,10 +43,12 @@ static const char rcsid[] = "#(@) $Id: xmlrpc.c,v 1.8.4.5 2008/12/17 21:45:31 il
  *   9/1999 - 10/2000
  * HISTORY
  *   $Log: xmlrpc.c,v $
- *   Revision 1.8.4.5  2008/12/17 21:45:31  iliaa
- *   MFB: remove fprintf usage
+ *   Revision 1.8.4.3.2.2  2008/12/09 17:22:12  iliaa
  *
- *   Revision 1.8.4.4  2008/09/10 00:09:04  felipe
+ *   MFH: Fixed bug #46746 (xmlrpc_decode_request outputs non-suppressable error
+ *   when given bad data).
+ *
+ *   Revision 1.8.4.3.2.1  2008/09/10 00:07:44  felipe
  *   MFH:
  *   - Merged fix from SF project (Import Jeff Lawsons patches for XML datetime bug fixes)
  *     Fixed bugs:
@@ -1171,12 +1173,12 @@ int XMLRPC_AddValueToVector(XMLRPC_VALUE target, XMLRPC_VALUE source) {
                   }
                }
                else {
-/*					fprintf (stderr,
+					/* fprintf (stderr,
 								"xmlrpc: attempted to add key/val pair to vector of type array\n"); */
                }
                break;
             default:
-/*				fprintf (stderr,
+				/* fprintf (stderr,
 							"xmlrpc: attempted to add value of unknown type to vector\n"); */
                break;
          }
@@ -1507,7 +1509,7 @@ void XMLRPC_CleanupValue(XMLRPC_VALUE value) {
                my_free(value);
                break;
             default:
-/*				fprintf (stderr,
+				/* fprintf (stderr,
 							"xmlrpc: attempted to free value of invalid type\n"); */
                break;
          }
diff --git a/ext/xmlrpc/libxmlrpc/xmlrpc_win32.h b/ext/xmlrpc/libxmlrpc/xmlrpc_win32.h
index 58c54bbb8..b212ccda5 100644
--- a/ext/xmlrpc/libxmlrpc/xmlrpc_win32.h
+++ b/ext/xmlrpc/libxmlrpc/xmlrpc_win32.h
@@ -3,9 +3,14 @@
 /* just some things needed to compile win32 */
 #include <windows.h>
 #include <stdlib.h>
-#define inline __inline
-#define snprintf _snprintf
-#define strcasecmp(s1, s2) stricmp(s1, s2)
-
+#ifndef inline
+# define inline __inline
+#endif
+#ifndef snprintf
+# define snprintf _snprintf
+#endif
+#ifndef strcasecmp
+# define strcasecmp(s1, s2) stricmp(s1, s2)
+#endif
 
 #endif
\ No newline at end of file
diff --git a/ext/xmlrpc/php_xmlrpc.h b/ext/xmlrpc/php_xmlrpc.h
index fa91bb410..94ee1f158 100644
--- a/ext/xmlrpc/php_xmlrpc.h
+++ b/ext/xmlrpc/php_xmlrpc.h
@@ -51,7 +51,7 @@
    +----------------------------------------------------------------------+
  */
 
-/* $Id: php_xmlrpc.h,v 1.11.2.1.2.4 2008/12/31 11:17:46 sebastian Exp $ */
+/* $Id: php_xmlrpc.h,v 1.11.2.1.2.2.2.3 2008/12/31 11:15:47 sebastian Exp $ */
 
 #ifndef _PHP_XMLRPC_H
 #define _PHP_XMLRPC_H
@@ -61,12 +61,6 @@
 extern zend_module_entry xmlrpc_module_entry;
 #define phpext_xmlrpc_ptr &xmlrpc_module_entry
 
-#ifdef PHP_WIN32
-#define PHP_XMLRPC_API __declspec(dllexport)
-#else
-#define PHP_XMLRPC_API
-#endif
-
 PHP_MINIT_FUNCTION(xmlrpc);
 PHP_MINFO_FUNCTION(xmlrpc);
 
diff --git a/ext/xmlrpc/xmlrpc-epi-php.c b/ext/xmlrpc/xmlrpc-epi-php.c
index 415542477..1cd296fb1 100644
--- a/ext/xmlrpc/xmlrpc-epi-php.c
+++ b/ext/xmlrpc/xmlrpc-epi-php.c
@@ -51,7 +51,7 @@
    +----------------------------------------------------------------------+
  */
 
-/* $Id: xmlrpc-epi-php.c,v 1.39.2.5.2.13 2009/01/27 15:02:43 felipe Exp $ */
+/* $Id: xmlrpc-epi-php.c,v 1.39.2.5.2.6.2.19 2009/03/19 00:18:48 iliaa Exp $ */
 
 /**********************************************************************
 * BUGS:                                                               *
@@ -75,21 +75,87 @@
 
 static int le_xmlrpc_server;
 
-zend_function_entry xmlrpc_functions[] = {
-	PHP_FE(xmlrpc_encode,									NULL) 
-	PHP_FE(xmlrpc_decode,									NULL)
-	PHP_FE(xmlrpc_decode_request,							second_arg_force_ref)
-	PHP_FE(xmlrpc_encode_request,							NULL)
-	PHP_FE(xmlrpc_get_type,									NULL)
-	PHP_FE(xmlrpc_set_type,									first_arg_force_ref)
-	PHP_FE(xmlrpc_is_fault,									NULL)
-	PHP_FE(xmlrpc_server_create,							NULL)
-	PHP_FE(xmlrpc_server_destroy,							NULL)
-	PHP_FE(xmlrpc_server_register_method,					NULL)
-	PHP_FE(xmlrpc_server_call_method,						NULL)
-	PHP_FE(xmlrpc_parse_method_descriptions,				NULL)
-	PHP_FE(xmlrpc_server_add_introspection_data,			NULL)
-	PHP_FE(xmlrpc_server_register_introspection_callback,	NULL)
+/* {{{ arginfo */
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_encode, 0, 0, 1)
+	ZEND_ARG_INFO(0, value)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_decode, 0, 0, 1)
+	ZEND_ARG_INFO(0, value)
+	ZEND_ARG_INFO(0, encoding)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_decode_request, 0, 0, 2)
+	ZEND_ARG_INFO(0, xml)
+	ZEND_ARG_INFO(1, method)
+	ZEND_ARG_INFO(0, encoding)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_encode_request, 0, 0, 2)
+	ZEND_ARG_INFO(0, method)
+	ZEND_ARG_INFO(0, params)
+	ZEND_ARG_INFO(0, output_options)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_set_type, 0, 0, 2)
+	ZEND_ARG_INFO(1, value)
+	ZEND_ARG_INFO(0, type)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_is_fault, 0, 0, 1)
+	ZEND_ARG_INFO(0, arg)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO(arginfo_xmlrpc_server_create, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_destroy, 0, 0, 1)
+	ZEND_ARG_INFO(0, server)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_register_method, 0, 0, 3)
+	ZEND_ARG_INFO(0, server)
+	ZEND_ARG_INFO(0, method_name)
+	ZEND_ARG_INFO(0, function)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_call_method, 0, 0, 3)
+	ZEND_ARG_INFO(0, server)
+	ZEND_ARG_INFO(0, xml)
+	ZEND_ARG_INFO(0, user_data)
+	ZEND_ARG_INFO(0, output_options)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_parse_method_descriptions, 0, 0, 1)
+	ZEND_ARG_INFO(0, xml)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_add_introspection_data, 0, 0, 2)
+	ZEND_ARG_INFO(0, server)
+	ZEND_ARG_INFO(0, desc)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_register_introspection_callback, 0, 0, 2)
+	ZEND_ARG_INFO(0, server)
+	ZEND_ARG_INFO(0, function)
+ZEND_END_ARG_INFO()
+/* }}} */
+
+const zend_function_entry xmlrpc_functions[] = {
+	PHP_FE(xmlrpc_encode,									arginfo_xmlrpc_encode) 
+	PHP_FE(xmlrpc_decode,									arginfo_xmlrpc_decode)
+	PHP_FE(xmlrpc_decode_request,							arginfo_xmlrpc_decode_request)
+	PHP_FE(xmlrpc_encode_request,							arginfo_xmlrpc_encode_request)
+	PHP_FE(xmlrpc_get_type,									arginfo_xmlrpc_encode)
+	PHP_FE(xmlrpc_set_type,									arginfo_xmlrpc_set_type)
+	PHP_FE(xmlrpc_is_fault,									arginfo_xmlrpc_is_fault)
+	PHP_FE(xmlrpc_server_create,							arginfo_xmlrpc_server_create)
+	PHP_FE(xmlrpc_server_destroy,							arginfo_xmlrpc_server_destroy)
+	PHP_FE(xmlrpc_server_register_method,					arginfo_xmlrpc_server_register_method)
+	PHP_FE(xmlrpc_server_call_method,						arginfo_xmlrpc_server_call_method)
+	PHP_FE(xmlrpc_parse_method_descriptions,				arginfo_xmlrpc_parse_method_descriptions)
+	PHP_FE(xmlrpc_server_add_introspection_data,			arginfo_xmlrpc_server_add_introspection_data)
+	PHP_FE(xmlrpc_server_register_introspection_callback,	arginfo_xmlrpc_server_register_introspection_callback)
 	{NULL, NULL, NULL}
 };
 
@@ -108,9 +174,6 @@ zend_module_entry xmlrpc_module_entry = {
 
 #ifdef COMPILE_DL_XMLRPC
 ZEND_GET_MODULE(xmlrpc)
-# ifdef PHP_WIN32
-# include "zend_arg_defs.c"
-# endif
 #endif
 
 /*******************************
@@ -189,7 +252,7 @@ typedef struct _xmlrpc_callback_data {
 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(zval* xml_in, zval* encoding_in, zval* method_name_out);
+zval* decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval* method_name_out);
 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);
@@ -199,7 +262,7 @@ int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE type);
 * startup / shutdown *
 *********************/
 
-static void destroy_server_data(xmlrpc_server_data *server)
+static void destroy_server_data(xmlrpc_server_data *server TSRMLS_DC)
 {
 	if (server) {
 		XMLRPC_ServerDestroy(server->server_ptr);
@@ -219,7 +282,7 @@ static void destroy_server_data(xmlrpc_server_data *server)
 static void xmlrpc_server_destructor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 {
 	if (rsrc && rsrc->ptr) {
-		destroy_server_data((xmlrpc_server_data*) rsrc->ptr);
+		destroy_server_data((xmlrpc_server_data*) rsrc->ptr TSRMLS_CC);
 	}
 }
 
@@ -357,8 +420,8 @@ static void set_output_options(php_output_options* options, zval* output_opts)
 			}
 
 			/* 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) {
+			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));
 				}
 			}
@@ -368,44 +431,37 @@ static void set_output_options(php_output_options* options, zval* output_opts)
 				/* 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)) {
+
+					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)) {
+								} 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)) {
+								} 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)) {
+								} else if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_MARKUP)) {
 									options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_markup_escaping;
 								}
 							}
-						}
-						else {
+						} 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)) {
+				} 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)) {
+					} 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)) {
+					} 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)) {
+					} else if (!strcmp(Z_STRVAL_PP(val), ESCAPING_VALUE_MARKUP)) {
 						options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping;
 					}
 				}
@@ -431,42 +487,42 @@ static XMLRPC_VECTOR_TYPE determine_vector_type (HashTable *ht)
 	char* my_key;
 
 	zend_hash_internal_pointer_reset(ht);
-	while(1) {
+	while (1) {
 		int res = my_zend_hash_get_current_key(ht, &my_key, &num_index);
-		if(res == HASH_KEY_IS_LONG) {
-			if(bStruct) {
+		
+		if (res == HASH_KEY_IS_LONG) {
+			if (bStruct) {
 				bMixed = 1;
 				break;
 			}
 			bArray = 1;
-		}
-		else if(res == HASH_KEY_NON_EXISTANT) {
+		} else if (res == HASH_KEY_NON_EXISTANT) {
 			break;
-		}
-		else if(res == HASH_KEY_IS_STRING) {
-			if(bArray) {
+		} 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);
+	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)
 {
 	XMLRPC_VALUE xReturn = NULL;
-	if(in_val) {
+
+	if (in_val) {
 		zval* val = NULL;
 		XMLRPC_VALUE_TYPE type = get_zval_xmlrpc_type(in_val, &val);
-		if(val) {
-			switch(type) {
+	
+		if (val) {
+			switch (type) {
 				case xmlrpc_base64:
-					if(Z_TYPE_P(val) == IS_NULL) {
+					if (Z_TYPE_P(val) == IS_NULL) {
 						xReturn = XMLRPC_CreateValueEmpty();
 						XMLRPC_SetValueID(xReturn, key, 0);
 					} else {
@@ -488,59 +544,60 @@ static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int dep
 				case xmlrpc_double:
 					convert_to_double(val);
 					xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL_P(val));
-				break;
+					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)));
+					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;
+						}
 
-					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;
-							case HASH_KEY_IS_STRING:
-							case HASH_KEY_IS_LONG:
-								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;
+						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;
+								case HASH_KEY_IS_STRING:
+								case HASH_KEY_IS_LONG:
+									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));
 						}
-						zend_hash_move_forward(Z_ARRVAL_P(val));
 					}
-				}
-				break;
-			default:
-				break;
+					break;
+				default:
+					break;
 			}
 		}
 	}
-   return xReturn;
+	return xReturn;
 }
 
 static XMLRPC_VALUE PHP_to_XMLRPC(zval* root_val TSRMLS_DC)
@@ -554,7 +611,7 @@ static zval* XMLRPC_to_PHP(XMLRPC_VALUE el)
 	zval* elem = NULL;
 	const char* pStr;
 
-	if(el) {
+	if (el) {
 		XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(el);
 
 		MAKE_STD_ZVAL(elem); /* init. very important.  spent a frustrating day finding this out. */
@@ -565,7 +622,7 @@ static zval* XMLRPC_to_PHP(XMLRPC_VALUE el)
 				break;
 			case xmlrpc_string:
 				pStr = XMLRPC_GetValueString(el);
-				if(pStr) {
+				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;
@@ -580,23 +637,23 @@ static zval* XMLRPC_to_PHP(XMLRPC_VALUE 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_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:
+			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;
+				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:
+			case xmlrpc_vector:
 				array_init(elem);
 				{
 					XMLRPC_VALUE xIter = XMLRPC_VectorRewind(el);
@@ -610,33 +667,33 @@ static zval* XMLRPC_to_PHP(XMLRPC_VALUE el)
 					}
 				}
 				break;
-         	default:
-            	break;
-      	}
+			default:
+				break;
+		}
 		set_zval_xmlrpc_type(elem, type);
 	}
 	return elem;
 }
 
-/* {{{ proto string xmlrpc_encode_request(string method, mixed params)
+/* {{{ proto string xmlrpc_encode_request(string method, mixed params [, array output_options])
    Generates XML for a method request */
 PHP_FUNCTION(xmlrpc_encode_request)
 {
 	XMLRPC_REQUEST xRequest = NULL;
-	zval **method, **vals, **out_opts;
-	char* outBuf;
+	char *outBuf;
+	zval **method, **vals, *out_opts = NULL;
 	php_output_options out;
 
-	if (ZEND_NUM_ARGS() < 2 || ZEND_NUM_ARGS() > 3 || (zend_get_parameters_ex(ZEND_NUM_ARGS(), &method, &vals, &out_opts) == FAILURE)) {
-		WRONG_PARAM_COUNT; /* prints/logs a warning and returns */
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZ|a", &method, &vals, &out_opts) == FAILURE) {
+		return;
 	}
 
-	set_output_options(&out, (ZEND_NUM_ARGS() == 3) ? *out_opts : 0);
+	set_output_options(&out, out_opts ? out_opts : 0);
 
-	if(return_value_used) {
+	if (return_value_used) {
 		xRequest = XMLRPC_RequestNew();
 
-		if(xRequest) {
+		if (xRequest) {
 			XMLRPC_RequestSetOutputOptions(xRequest, &out.xmlrpc_out);
 			if (Z_TYPE_PP(method) == IS_NULL) {
 				XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_response);
@@ -650,7 +707,7 @@ PHP_FUNCTION(xmlrpc_encode_request)
 			}
 
 			outBuf = XMLRPC_REQUEST_ToXML(xRequest, 0);
-			if(outBuf) {
+			if (outBuf) {
 				RETVAL_STRING(outBuf, 1);
 				free(outBuf);
 			}
@@ -672,19 +729,19 @@ PHP_FUNCTION(xmlrpc_encode)
 	zval **arg1;
 	char *outBuf;
 
-	if (ZEND_NUM_ARGS() != 1 || (zend_get_parameters_ex(1, &arg1) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg1) == FAILURE) {
+		return;
 	}
 
-	if( return_value_used ) {
+	if (return_value_used) {
 		/* convert native php type to xmlrpc type */
 		xOut = PHP_to_XMLRPC(*arg1 TSRMLS_CC);
 
 		/* generate raw xml from xmlrpc data */
 		outBuf = XMLRPC_VALUE_ToXML(xOut, 0);
 
-		if(xOut) {
-			if(outBuf) {
+		if (xOut) {
+			if (outBuf) {
 				RETVAL_STRING(outBuf, 1);
 				free(outBuf);
 			}
@@ -695,22 +752,21 @@ PHP_FUNCTION(xmlrpc_encode)
 }
 /* }}} */
 
-
-zval* decode_request_worker (zval* xml_in, zval* encoding_in, zval* method_name_out)
+zval* decode_request_worker(char *xml_in, int xml_in_len, char *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;
+	opts.xml_elem_opts.encoding = encoding_in ? utf8_get_encoding_id_from_string(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) {
+	response = XMLRPC_REQUEST_FromXML(xml_in, xml_in_len, &opts);
+	if (response) {
 		/* convert xmlrpc data to native php types */
 		retval = XMLRPC_to_PHP(XMLRPC_RequestGetData(response));
 
-		if(XMLRPC_RequestGetRequestType(response) == xmlrpc_request_call) {
-			if(method_name_out) {
+		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));
@@ -723,27 +779,25 @@ zval* decode_request_worker (zval* xml_in, zval* encoding_in, zval* method_name_
 	}
 	return retval;
 }
+/* }}} */
 
 /* {{{ proto array xmlrpc_decode_request(string xml, string& method [, string encoding])
    Decodes XML into native PHP types */
 PHP_FUNCTION(xmlrpc_decode_request)
 {
-	zval **xml, **method, **encoding = NULL;
-	int argc = ZEND_NUM_ARGS();
+	char *xml, *encoding = NULL;
+	zval **method;
+	int xml_len, encoding_len = 0;
 
-	if (argc < 2 || argc > 3 || (zend_get_parameters_ex(argc, &xml, &method, &encoding) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
+		return;
 	}
 
-	convert_to_string_ex(xml);
 	convert_to_string_ex(method);
-	if(argc == 3) {
-		convert_to_string_ex(encoding);
-	}
 
-	if(return_value_used) {
-		zval* retval = decode_request_worker(*xml, encoding ? *encoding : NULL, *method);
-		if(retval) {
+	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);
 		}
@@ -751,26 +805,20 @@ PHP_FUNCTION(xmlrpc_decode_request)
 }
 /* }}} */
 
-
 /* {{{ proto array xmlrpc_decode(string xml [, string encoding])
    Decodes XML into native PHP types */
 PHP_FUNCTION(xmlrpc_decode)
 {
-	zval **arg1, **arg2 = NULL;
-	int argc = ZEND_NUM_ARGS();
-
-	if (argc < 1 || argc > 2 || (zend_get_parameters_ex(argc, &arg1, &arg2) == FAILURE)) {
-		WRONG_PARAM_COUNT;
-	}
+	char *arg1, *arg2 = NULL;
+	int arg1_len, arg2_len = 0;
 
-	convert_to_string_ex(arg1);
-	if(argc == 2) {
-		convert_to_string_ex(arg2);
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &arg1, &arg1_len, &arg2, &arg2_len) == FAILURE) {
+		return;
 	}
 
-	if(return_value_used) {
-		zval* retval = decode_request_worker(*arg1, arg2 ? *arg2 : NULL, NULL);
-		if(retval) {
+	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);
 		}
@@ -778,7 +826,6 @@ PHP_FUNCTION(xmlrpc_decode)
 }
 /* }}} */
 
-
 /*************************
 * server related methods *
 *************************/
@@ -787,11 +834,11 @@ PHP_FUNCTION(xmlrpc_decode)
    Creates an xmlrpc server */
 PHP_FUNCTION(xmlrpc_server_create)
 {
-	if(ZEND_NUM_ARGS() != 0) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
 	}
 
-	if(return_value_used) {
+	if (return_value_used) {
 		zval *method_map, *introspection_map;
 		xmlrpc_server_data *server = emalloc(sizeof(xmlrpc_server_data));
 		MAKE_STD_ZVAL(method_map);
@@ -817,35 +864,31 @@ PHP_FUNCTION(xmlrpc_server_create)
    Destroys server resources */
 PHP_FUNCTION(xmlrpc_server_destroy)
 {
-	zval **arg1;
-	int bSuccess = FAILURE;
+	zval *arg1;
+	int bSuccess = FAILURE, type;
+	xmlrpc_server_data *server;
 
-	if (ZEND_NUM_ARGS() != 1 || (zend_get_parameters_ex(1, &arg1) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
+		return;
 	}
 
-	if(Z_TYPE_PP(arg1) == IS_RESOURCE) {
-		int type;
-
-		xmlrpc_server_data *server = zend_list_find(Z_LVAL_PP(arg1), &type);
+	server = zend_list_find(Z_LVAL_P(arg1), &type);
 
-		if(server && type == le_xmlrpc_server) {
-			bSuccess = zend_list_delete(Z_LVAL_PP(arg1));
+	if (server && type == le_xmlrpc_server) {
+		bSuccess = zend_list_delete(Z_LVAL_P(arg1));
 
-			/* called by hashtable destructor
-			 * destroy_server_data(server);
-			 */
-		}
+		/* called by hashtable destructor
+		 * destroy_server_data(server);
+		 */
 	}
 	RETVAL_LONG(bSuccess == SUCCESS);
 }
 /* }}} */
-
            
 /* called by xmlrpc C engine as method handler for all registered methods.
  * it then calls the corresponding PHP function to handle the method.
  */
-static XMLRPC_VALUE php_xmlrpc_callback(XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* data)
+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;
@@ -871,14 +914,15 @@ static XMLRPC_VALUE php_xmlrpc_callback(XMLRPC_SERVER server, XMLRPC_REQUEST xRe
 
 	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, **php_function;
-	zval* callback_params[1];
+	zval *callback_params[1];
 	char *php_function_name;
 	xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
 	TSRMLS_FETCH();
@@ -888,10 +932,9 @@ static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data)
 
 	/* 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)) {
+	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;
@@ -902,16 +945,16 @@ static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data)
 
 					xData = XMLRPC_IntrospectionCreateDescription(Z_STRVAL(retval), &err);
 
-					if(xData) {
-						if(!XMLRPC_ServerAddIntrospectionData(server, xData)) {
+					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) {
+						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);
+								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);
 						}
@@ -930,37 +973,40 @@ static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data)
 		}
 		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));
 }
+/* }}} */
 
 /* {{{ proto bool xmlrpc_server_register_method(resource server, string method_name, string function)
    Register a PHP function to handle method matching method_name */
 PHP_FUNCTION(xmlrpc_server_register_method)
 {
-	zval **method_key, **method_name, **handle, *method_name_save;
+	char *method_key;
+	int method_key_len;
+	zval *handle, *method_name_save, **method_name;
 	int type;
 	xmlrpc_server_data* server;
 
-	if (ZEND_NUM_ARGS() != 3 || (zend_get_parameters_ex(3, &handle, &method_key, &method_name) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ", &handle, &method_key, &method_key_len, &method_name) == FAILURE) {
+		return;
 	}
 
-	server = zend_list_find(Z_LVAL_PP(handle), &type);
+	server = zend_list_find(Z_LVAL_P(handle), &type);
 
-	if(type == le_xmlrpc_server) {
+	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, Z_STRVAL_PP(method_key), php_xmlrpc_callback)) {
+		if (XMLRPC_ServerRegisterMethod(server->server_ptr, method_key, php_xmlrpc_callback)) {
 			/* save for later use */
 			MAKE_STD_ZVAL(method_name_save);
 			*method_name_save = **method_name;
 			zval_copy_ctor(method_name_save);
 
 			/* register our php method */
-			add_zval(server->method_map, Z_STRVAL_PP(method_key), &method_name_save);
+			add_zval(server->method_map, method_key, &method_name_save);
 
 			RETURN_BOOL(1);
 		}
@@ -969,22 +1015,21 @@ PHP_FUNCTION(xmlrpc_server_register_method)
 }
 /* }}} */
 
-
 /* {{{ 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)
 {
-	zval **method_name, **handle, *method_name_save;
+	zval **method_name, *handle, *method_name_save;
 	int type;
 	xmlrpc_server_data* server;
 
-	if (ZEND_NUM_ARGS() != 2 || (zend_get_parameters_ex(2, &handle, &method_name) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &handle, &method_name) == FAILURE) {
+		return;
 	}
 
-	server = zend_list_find(Z_LVAL_PP(handle), &type);
+	server = zend_list_find(Z_LVAL_P(handle), &type);
 
-	if(type == le_xmlrpc_server) {
+	if (type == le_xmlrpc_server) {
 		/* save for later use */
 		MAKE_STD_ZVAL(method_name_save);
 		*method_name_save = **method_name;
@@ -999,7 +1044,6 @@ PHP_FUNCTION(xmlrpc_server_register_introspection_callback)
 }
 /* }}} */
 
-
 /* this function is itchin for a re-write */
 
 /* {{{ proto mixed xmlrpc_server_call_method(resource server, string xml, mixed user_data [, array output_options])
@@ -1010,32 +1054,32 @@ PHP_FUNCTION(xmlrpc_server_call_method)
 	XMLRPC_REQUEST xRequest;
 	STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS input_opts;
 	xmlrpc_server_data* server;
-	zval **rawxml, **caller_params, **handle, **output_opts = NULL;
-	int type;
+	zval **caller_params, *handle, **output_opts = NULL;
+	char *rawxml;
+	int rawxml_len, 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;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ|Z", &handle, &rawxml, &rawxml_len, &caller_params, &output_opts) != SUCCESS) {
+		return;
 	}
 	/* user output options */
 	if (argc == 3) {
 		set_output_options(&out, NULL);
-	}
-	else {
+	} else {
 		set_output_options(&out, *output_opts);
 	}
 
-	server = zend_list_find(Z_LVAL_PP(handle), &type);
+	server = zend_list_find(Z_LVAL_P(handle), &type);
 
-	if(type == le_xmlrpc_server) {
+	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(Z_STRVAL_PP(rawxml), Z_STRLEN_PP(rawxml), &input_opts);
+		xRequest = XMLRPC_REQUEST_FromXML(rawxml, rawxml_len, &input_opts);
 
-		if(xRequest) {
+		if (xRequest) {
 			const char* methodname = XMLRPC_RequestGetMethodName(xRequest);
 			zval **php_function;
 			XMLRPC_VALUE xAnswer = NULL;
@@ -1057,10 +1101,10 @@ PHP_FUNCTION(xmlrpc_server_call_method)
 			data.server = server;
 
 			/* 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) {
+			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) {
 
 				data.php_function = *php_function;
 			}
@@ -1070,18 +1114,18 @@ PHP_FUNCTION(xmlrpc_server_call_method)
 			 * or somesuch.
 			 */
 			xAnswer = XMLRPC_ServerCallMethod(server->server_ptr, xRequest, &data);
-			if(xAnswer && out.b_php_out) {
+			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) {
+			} else if (data.php_executed && !out.b_php_out) {
 				xAnswer = PHP_to_XMLRPC(data.return_data TSRMLS_CC);
 			}
 
 			/* should we return data as xml? */
-			if(!out.b_php_out) {
+			if (!out.b_php_out) {
 				XMLRPC_REQUEST xResponse = XMLRPC_RequestNew();
-				if(xResponse) {
+				if (xResponse) {
 					char *outBuf = 0;
 					int buf_len = 0;
 
@@ -1100,7 +1144,7 @@ PHP_FUNCTION(xmlrpc_server_call_method)
 
 					/* generate xml */
 					outBuf = XMLRPC_REQUEST_ToXML(xResponse, &buf_len);
-					if(outBuf) {
+					if (outBuf) {
 						RETVAL_STRINGL(outBuf, buf_len, 1);
 						free(outBuf);
 					}
@@ -1118,7 +1162,7 @@ PHP_FUNCTION(xmlrpc_server_call_method)
 			zval_dtor(data.return_data);
 			FREE_ZVAL(data.return_data);
 
-			if(xAnswer) {
+			if (xAnswer) {
 				XMLRPC_CleanupValue(xAnswer);
 			}
 
@@ -1128,23 +1172,22 @@ PHP_FUNCTION(xmlrpc_server_call_method)
 }
 /* }}} */
 
-
 /* {{{ proto int xmlrpc_server_add_introspection_data(resource server, array desc)
    Adds introspection documentation  */
 PHP_FUNCTION(xmlrpc_server_add_introspection_data)
 {
-	zval **handle, **desc;
+	zval *handle, *desc;
 	int type;
 	xmlrpc_server_data* server;
 
-	if (ZEND_NUM_ARGS() != 2 || (zend_get_parameters_ex(2, &handle, &desc) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &handle, &desc) == FAILURE) {
+		return;
 	}
 
-	server = zend_list_find(Z_LVAL_PP(handle), &type);
+	server = zend_list_find(Z_LVAL_P(handle), &type);
 
 	if (type == le_xmlrpc_server) {
-		XMLRPC_VALUE xDesc = PHP_to_XMLRPC(*desc TSRMLS_CC);
+		XMLRPC_VALUE xDesc = PHP_to_XMLRPC(desc TSRMLS_CC);
 		if (xDesc) {
 			int retval = XMLRPC_ServerAddIntrospectionData(server->server_ptr, xDesc);
 			XMLRPC_CleanupValue(xDesc);
@@ -1155,26 +1198,25 @@ PHP_FUNCTION(xmlrpc_server_add_introspection_data)
 }
 /* }}} */
 
-
 /* {{{ proto array xmlrpc_parse_method_descriptions(string xml)
    Decodes XML into a list of method descriptions */
 PHP_FUNCTION(xmlrpc_parse_method_descriptions)
 {
-	zval **arg1, *retval;
+	zval *retval;
+	char *arg1;
+	int arg1_len;
 
-	if (ZEND_NUM_ARGS() != 1 || (zend_get_parameters_ex(1, &arg1) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg1, &arg1_len) == FAILURE) {
+		return;
 	}
 
-	convert_to_string_ex(arg1);
-
-	if(return_value_used) {
+	if (return_value_used) {
 		STRUCT_XMLRPC_ERROR err = {0};
-		XMLRPC_VALUE xVal = XMLRPC_IntrospectionCreateDescription(Z_STRVAL_PP(arg1), &err);
-		if(xVal) {
+		XMLRPC_VALUE xVal = XMLRPC_IntrospectionCreateDescription(arg1, &err);
+		if (xVal) {
 			retval = XMLRPC_to_PHP(xVal);
 
-			if(retval) {
+			if (retval) {
 				*return_value = *retval;
 				zval_copy_ctor(return_value);
 			}
@@ -1182,9 +1224,9 @@ PHP_FUNCTION(xmlrpc_parse_method_descriptions)
 			XMLRPC_CleanupValue(xVal);
 		} else {
 			/* could not create description */
-			if(err.xml_elem_error.parser_code) {
+			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");
 			}
@@ -1195,7 +1237,6 @@ PHP_FUNCTION(xmlrpc_parse_method_descriptions)
 }
 /* }}} */
 
-
 /************
 * type data *
 ************/
@@ -1205,7 +1246,7 @@ PHP_FUNCTION(xmlrpc_parse_method_descriptions)
 #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;
@@ -1228,9 +1269,10 @@ static const char** get_type_str_mapping(void)
 	}
 	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();
 
@@ -1240,9 +1282,10 @@ const char* xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype)
 		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;
@@ -1256,9 +1299,10 @@ XMLRPC_VALUE_TYPE xmlrpc_str_as_type(const char* str)
 	}
 	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;
@@ -1272,20 +1316,20 @@ XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str)
 	}
 	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();
 
 	/* we only really care about strings because they can represent
-	* base64 and datetime.  all other types have corresponding php types
-	*/
+	 * 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);
@@ -1297,11 +1341,11 @@ int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype)
 			Z_STRVAL_P(type) = estrdup(typestr);
 			Z_STRLEN_P(type) = strlen(typestr);
 
-			if(newtype == xmlrpc_datetime) {
+			if (newtype == xmlrpc_datetime) {
 				XMLRPC_VALUE v = XMLRPC_CreateValueDateTime_ISO8601(NULL, value->value.str.val);
-				if(v) {
+				if (v) {
 					time_t timestamp = XMLRPC_GetValueDateTime(v);
-					if(timestamp) {
+					if (timestamp) {
 						zval* ztimestamp;
 
 						MAKE_STD_ZVAL(ztimestamp);
@@ -1310,28 +1354,29 @@ int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype)
 						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)) {
+						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);
 						}
 					} else {
 						zval_ptr_dtor(&type);
-	       			}
-               		XMLRPC_CleanupValue(v);
-            	} else {
+					}
+					XMLRPC_CleanupValue(v);
+				} else {
 					zval_ptr_dtor(&type);
-	    		}
-         	} else {
+				}
+			} 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();
@@ -1368,17 +1413,17 @@ XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue)
 				type = xmlrpc_vector;
 				break;
 			case IS_OBJECT:
-			{
-				zval** attr;
-				type = xmlrpc_vector;
+				{
+					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 (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;
 				}
-				break;
-			}
 		}
 
 		/* if requested, return an unmolested (magic removed) copy of the value */
@@ -1394,29 +1439,31 @@ XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue)
 			}
 		}
 	}
+
 	return type;
 }
-
+/* }}} */
 
 /* {{{ proto bool xmlrpc_set_type(string value, string type)
    Sets xmlrpc type, base64 or datetime, for a PHP string value */
 PHP_FUNCTION(xmlrpc_set_type)
 {
-	zval **arg, **type;
+	zval **arg;
+	char *type;
+	int type_len;
 	XMLRPC_VALUE_TYPE vtype;
 
-	if (ZEND_NUM_ARGS() != 2 || (zend_get_parameters_ex(2, &arg, &type) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &arg, &type, &type_len) == FAILURE) {
+		return;
 	}
 
-	convert_to_string_ex(type);
-	vtype = xmlrpc_str_as_type(Z_STRVAL_PP(type));
+	vtype = xmlrpc_str_as_type(type);
 	if (vtype != xmlrpc_none) {
 		if (set_zval_xmlrpc_type(*arg, vtype) == SUCCESS) {
 			RETURN_TRUE;
 		}
 	} else {
-		zend_error(E_WARNING,"invalid type '%s' passed to xmlrpc_set_type()", Z_STRVAL_PP(type));
+		zend_error(E_WARNING,"invalid type '%s' passed to xmlrpc_set_type()", type);
 	}
 	RETURN_FALSE;
 }
@@ -1430,8 +1477,8 @@ PHP_FUNCTION(xmlrpc_get_type)
 	XMLRPC_VALUE_TYPE type;
 	XMLRPC_VECTOR_TYPE vtype = xmlrpc_vector_none;
 
-	if (ZEND_NUM_ARGS() != 1 || (zend_get_parameters_ex(1, &arg) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+		return;
 	}
 
 	type = get_zval_xmlrpc_type(*arg, 0);
@@ -1447,33 +1494,27 @@ PHP_FUNCTION(xmlrpc_get_type)
    Determines if an array value represents an XMLRPC fault. */
 PHP_FUNCTION(xmlrpc_is_fault)
 {
-	zval **arg, **val;
+	zval *arg, **val;
 
-	if (ZEND_NUM_ARGS() != 1 || (zend_get_parameters_ex(1, &arg) == FAILURE)) {
-		WRONG_PARAM_COUNT;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &arg) == FAILURE) {
+		return;
 	}
 
-	if (Z_TYPE_PP(arg) != IS_ARRAY) {
-		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Array argument expected");
-	} else {
-		/* The "correct" way to do this would be to call the xmlrpc
-		 * library XMLRPC_ValueIsFault() func.  However, doing that
-		 * would require us to create an xmlrpc value from the php
-		 * 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_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) {
-			RETURN_TRUE;
-		}
+	/* The "correct" way to do this would be to call the xmlrpc
+	 * library XMLRPC_ValueIsFault() func.  However, doing that
+	 * would require us to create an xmlrpc value from the php
+	 * 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) {
+		RETURN_TRUE;
 	}
 
 	RETURN_FALSE;
 }
 /* }}} */
 
-
-
 /*
  * Local variables:
  * tab-width: 4