Imported Upstream version 5.2.9.dfsg.1upstream/5.2.9.dfsg.1

9 files changed, 645 insertions, 504 deletions

diff --git a/ext/xmlrpc/libxmlrpc/xml_element.c b/ext/xmlrpc/libxmlrpc/xml_element.c
index 15fc3bf0b..faf76714e 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.1 2006/07/30 11:34:02 tony2001 Exp $";
+static const char rcsid[] = "#(@) $Id: xml_element.c,v 1.9.4.3 2008/12/17 21:45:31 iliaa Exp $";
 
 
 
@@ -44,6 +44,13 @@ static const char rcsid[] = "#(@) $Id: xml_element.c,v 1.9.4.1 2006/07/30 11:34:
  *   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.2  2008/12/17 00:30:48  iliaa
+ *
+ *   MFH: removed unused var
+ *
  *   Revision 1.9.4.1  2006/07/30 11:34:02  tony2001
  *   MFH: fix compile warnings (#38257)
  *
@@ -378,7 +385,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) {
@@ -716,7 +723,7 @@ xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTI
          int line_num = XML_GetCurrentLineNumber(parser);
          int col_num = XML_GetCurrentColumnNumber(parser);
          long byte_idx = XML_GetCurrentByteIndex(parser);
-         int byte_total = XML_GetCurrentByteCount(parser);
+/*         int byte_total = XML_GetCurrentByteCount(parser); */
          const char * error_str = XML_ErrorString(err_code);
          if(byte_idx >= 0) {
              snprintf(buf, 
@@ -725,7 +732,7 @@ xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTI
                       byte_idx > 10  ? 10 : byte_idx,
                       in_buf + (byte_idx > 10 ? byte_idx - 10 : byte_idx));
          }
-
+/*
          fprintf(stderr, "expat reports error code %i\n"
                 "\tdescription: %s\n"
                 "\tline: %i\n"
@@ -734,7 +741,7 @@ xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTI
                 "\ttotal bytes: %i\n%s ",
                 err_code, error_str, line_num, 
                 col_num, byte_idx, byte_total, buf);
-
+*/
 
           /* error condition */
           if(error) {
diff --git a/ext/xmlrpc/libxmlrpc/xmlrpc.c b/ext/xmlrpc/libxmlrpc/xmlrpc.c
index dc5752fd5..7533016bf 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.3 2007/09/18 19:49:53 iliaa Exp $";
+static const char rcsid[] = "#(@) $Id: xmlrpc.c,v 1.8.4.5 2008/12/17 21:45:31 iliaa Exp $";
 
 
 /****h* ABOUT/xmlrpc
@@ -43,6 +43,16 @@ static const char rcsid[] = "#(@) $Id: xmlrpc.c,v 1.8.4.3 2007/09/18 19:49:53 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.4  2008/09/10 00:09:04  felipe
+ *   MFH:
+ *   - Merged fix from SF project (Import Jeff Lawsons patches for XML datetime bug fixes)
+ *     Fixed bugs:
+ *     #45226 (xmlrpc_set_type() segfaults with valid ISO8601 date string)
+ *     #18916 (xmlrpc_set_type() "not working")
+ *
  *   Revision 1.8.4.3  2007/09/18 19:49:53  iliaa
  *
  *   Fixed bug #42189 (xmlrpc_set_type() crashes php on invalid datetime
@@ -166,11 +176,21 @@ static const char rcsid[] = "#(@) $Id: xmlrpc.c,v 1.8.4.3 2007/09/18 19:49:53 il
 * Begin Time Functions *
 ***********************/
 
+static time_t mkgmtime(struct tm *tm)
+{
+    static const int mdays[12] = {0,31,59,90,120,151,181,212,243,273,304,334};
+
+    return ((((((tm->tm_year - 70) * 365) + mdays[tm->tm_mon] + tm->tm_mday-1 +
+                  (tm->tm_year-68-1+(tm->tm_mon>=2))/4) * 24) + tm->tm_hour) * 60 +
+        tm->tm_min) * 60 + tm->tm_sec;
+}
+
 static int date_from_ISO8601 (const char *text, time_t * value) {
    struct tm tm;
    int n;
    int i;
-	char buf[18];
+   char buf[30];
+	
 
 	if (strchr (text, '-')) {
 		char *p = (char *) text, *p2 = buf;
@@ -178,6 +198,9 @@ static int date_from_ISO8601 (const char *text, time_t * value) {
 			if (*p != '-') {
 				*p2 = *p;
 				p2++;
+				if (p2-buf >= sizeof(buf)) {
+					return -1;
+				}
 			}
 			p++;
 		}
@@ -187,10 +210,6 @@ static int date_from_ISO8601 (const char *text, time_t * value) {
 
    tm.tm_isdst = -1;
 
-   if(strlen(text) < 17) {
-      return -1;
-   }
-
 #define XMLRPC_IS_NUMBER(x) if (x < '0' || x > '9') return -1;
 
    n = 1000;
@@ -243,7 +262,7 @@ static int date_from_ISO8601 (const char *text, time_t * value) {
 
    tm.tm_year -= 1900;
 
-   *value = mktime(&tm);
+   *value = mkgmtime(&tm);
 
    return 0;
 
@@ -251,14 +270,14 @@ static int date_from_ISO8601 (const char *text, time_t * value) {
 
 static int date_to_ISO8601 (time_t value, char *buf, int length) {
    struct tm *tm, tmbuf;
-   tm = php_localtime_r(&value, &tmbuf);
+   tm = php_gmtime_r(&value, &tmbuf);
    if (!tm) {
 	   return 0;
    }
 #if 0  /* TODO: soap seems to favor this method. xmlrpc the latter. */
 	return strftime (buf, length, "%Y-%m-%dT%H:%M:%SZ", tm);
 #else
-   return strftime(buf, length, "%Y%m%dT%H:%M:%S", tm);
+   return strftime(buf, length, "%Y%m%dT%H:%M:%SZ", tm);
 #endif
 }
 
@@ -1152,13 +1171,13 @@ int XMLRPC_AddValueToVector(XMLRPC_VALUE target, XMLRPC_VALUE source) {
                   }
                }
                else {
-					fprintf (stderr,
-								"xmlrpc: attempted to add key/val pair to vector of type array\n");
+/*					fprintf (stderr,
+								"xmlrpc: attempted to add key/val pair to vector of type array\n"); */
                }
                break;
             default:
-				fprintf (stderr,
-							"xmlrpc: attempted to add value of unknown type to vector\n");
+/*				fprintf (stderr,
+							"xmlrpc: attempted to add value of unknown type to vector\n"); */
                break;
          }
       }
@@ -1488,8 +1507,8 @@ void XMLRPC_CleanupValue(XMLRPC_VALUE value) {
                my_free(value);
                break;
             default:
-				fprintf (stderr,
-							"xmlrpc: attempted to free value of invalid type\n");
+/*				fprintf (stderr,
+							"xmlrpc: attempted to free value of invalid type\n"); */
                break;
          }
       }
@@ -1529,8 +1548,7 @@ void XMLRPC_SetValueDateTime(XMLRPC_VALUE value, time_t time) {
       date_to_ISO8601(time, timeBuf, sizeof(timeBuf));
 
       if(timeBuf[0]) {
-         simplestring_clear(&value->str);
-         simplestring_add(&value->str, timeBuf);
+         XMLRPC_SetValueDateTime_ISO8601 (value, timeBuf);
       }
    }
 }
@@ -1706,8 +1724,11 @@ void XMLRPC_SetValueDateTime_ISO8601(XMLRPC_VALUE value, const char* s) {
    if(value) {
       time_t time_val = 0;
       if(s) {
+         value->type = xmlrpc_datetime;
          date_from_ISO8601(s, &time_val);
-         XMLRPC_SetValueDateTime(value, time_val);
+         value->i = time_val;
+         simplestring_clear(&value->str);
+         simplestring_add(&value->str, s);
       }
    }
 }
diff --git a/ext/xmlrpc/php_xmlrpc.h b/ext/xmlrpc/php_xmlrpc.h
index 68aeb5b81..fa91bb410 100644
--- a/ext/xmlrpc/php_xmlrpc.h
+++ b/ext/xmlrpc/php_xmlrpc.h
@@ -37,7 +37,7 @@
    +----------------------------------------------------------------------+
    | PHP Version 5                                                        |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2008 The PHP Group                                |
+   | Copyright (c) 1997-2009 The PHP Group                                |
    +----------------------------------------------------------------------+
    | This source file is subject to version 3.01 of the PHP license,      |
    | that is bundled with this package in the file LICENSE, and is        |
@@ -51,7 +51,7 @@
    +----------------------------------------------------------------------+
  */
 
-/* $Id: php_xmlrpc.h,v 1.11.2.1.2.3 2007/12/31 07:20:14 sebastian Exp $ */
+/* $Id: php_xmlrpc.h,v 1.11.2.1.2.4 2008/12/31 11:17:46 sebastian Exp $ */
 
 #ifndef _PHP_XMLRPC_H
 #define _PHP_XMLRPC_H
diff --git a/ext/xmlrpc/tests/bug18916.phpt b/ext/xmlrpc/tests/bug18916.phpt
new file mode 100644
index 000000000..b2eb525d8
--- /dev/null
+++ b/ext/xmlrpc/tests/bug18916.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Bug #18916 (xmlrpc_set_type() not working)
+--INI--
+date.timezone="America/Sao_Paulo"
+--FILE--
+<?php
+
+$params = date("Ymd\TH:i:s", time());
+xmlrpc_set_type($params, 'datetime');
+echo xmlrpc_encode($params);
+
+?>
+--EXPECTF--
+<?xml version="1.0" encoding="utf-8"?>
+<params>
+<param>
+ <value>
+  <dateTime.iso8601>%dT%d:%d:%d</dateTime.iso8601>
+ </value>
+</param>
+</params>
diff --git a/ext/xmlrpc/tests/bug40576.phpt b/ext/xmlrpc/tests/bug40576.phpt
index 6b73f4d2c..404aba32b 100644
--- a/ext/xmlrpc/tests/bug40576.phpt
+++ b/ext/xmlrpc/tests/bug40576.phpt
@@ -29,11 +29,11 @@ string(125) "<?xml version="1.0" encoding="utf-8"?>
 </param>
 </params>
 "
-string(128) "<?xml version="1.0" encoding="utf-8"?>
+string(130) "<?xml version="1.0" encoding="utf-8"?>
 <params>
 <param>
  <value>
-  <double>11234567891000</double>
+  <double>1.1234567891E+13</double>
  </value>
 </param>
 </params>
diff --git a/ext/xmlrpc/tests/bug45226.phpt b/ext/xmlrpc/tests/bug45226.phpt
new file mode 100644
index 000000000..af9b6c472
--- /dev/null
+++ b/ext/xmlrpc/tests/bug45226.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Bug #45226 (xmlrpc_set_type() segfaults with valid ISO8601 date string)
+--INI--
+date.timezone="America/Sao_Paulo"
+--FILE--
+<?php
+
+$d = date(DATE_ISO8601);
+xmlrpc_set_type($d, 'datetime');
+echo xmlrpc_encode_request('method.call', array('date' => $d));
+
+$d = '2008-01-01 20:00:00';
+xmlrpc_set_type($d, 'datetime');
+echo xmlrpc_encode_request('method.call', array('date' => $d));
+
+?>
+--EXPECTF--
+<?xml version="1.0" encoding="iso-8859-1"?>
+<methodCall>
+<methodName>method.call</methodName>
+<params>
+ <param>
+  <value>
+   <struct>
+    <member>
+     <name>date</name>
+     <value>
+      <dateTime.iso8601>%d-%d-%dT%d:%d:%d%s%d</dateTime.iso8601>
+     </value>
+    </member>
+   </struct>
+  </value>
+ </param>
+</params>
+</methodCall>
+<?xml version="1.0" encoding="iso-8859-1"?>
+<methodCall>
+<methodName>method.call</methodName>
+<params>
+ <param>
+  <value>
+   <struct>
+    <member>
+     <name>date</name>
+     <value>
+      <dateTime.iso8601>%d-%d-%d %d:%d:%d</dateTime.iso8601>
+     </value>
+    </member>
+   </struct>
+  </value>
+ </param>
+</params>
+</methodCall>
diff --git a/ext/xmlrpc/tests/bug45555.phpt b/ext/xmlrpc/tests/bug45555.phpt
new file mode 100644
index 000000000..376b14fec
--- /dev/null
+++ b/ext/xmlrpc/tests/bug45555.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Bug #45555 (Segfault with invalid non-string as register_introspection_callback)
+--FILE--
+<?php
+
+$options = array ();
+$request = xmlrpc_encode_request ("system.describeMethods", $options);
+$server = xmlrpc_server_create ();
+
+xmlrpc_server_register_introspection_callback($server, 1);
+xmlrpc_server_register_introspection_callback($server, array('foo', 'bar'));
+
+$options = array ('output_type' => 'xml', 'version' => 'xmlrpc');
+xmlrpc_server_call_method ($server, $request, NULL, $options);
+
+?>
+--EXPECTF--
+Warning: xmlrpc_server_call_method(): Invalid callback '1' passed in %s on line %d
+
+Warning: xmlrpc_server_call_method(): Invalid callback 'foo::bar' passed in %s on line %d
diff --git a/ext/xmlrpc/tests/bug45556.phpt b/ext/xmlrpc/tests/bug45556.phpt
new file mode 100644
index 000000000..0e463e669
--- /dev/null
+++ b/ext/xmlrpc/tests/bug45556.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Bug #45556 (Return value from callback isn't freed)
+--FILE--
+<?php
+
+$options = array ();
+$request = xmlrpc_encode_request ("system.describeMethods", $options);
+$server = xmlrpc_server_create ();
+
+
+function foo() { return 11111; }
+
+class bar {
+	static public function test() {
+		return 'foo';
+	}
+}
+
+xmlrpc_server_register_introspection_callback($server, 'foobar');
+xmlrpc_server_register_introspection_callback($server, array('bar', 'test'));
+xmlrpc_server_register_introspection_callback($server, array('foo', 'bar'));
+
+$options = array ('output_type' => 'xml', 'version' => 'xmlrpc');
+xmlrpc_server_call_method ($server, $request, NULL, $options);
+
+?>
+--EXPECTF--
+Warning: xmlrpc_server_call_method(): Invalid callback 'foobar' passed in %s on line %d
+
+Warning: xmlrpc_server_call_method(): xml parse error: [line 1, column 1, message: Invalid document end] Unable to add introspection data returned from bar::test() in %s on line %d
+
+Warning: xmlrpc_server_call_method(): Invalid callback 'foo::bar' passed in %s on line %d
diff --git a/ext/xmlrpc/xmlrpc-epi-php.c b/ext/xmlrpc/xmlrpc-epi-php.c
index 87b899469..415542477 100644
--- a/ext/xmlrpc/xmlrpc-epi-php.c
+++ b/ext/xmlrpc/xmlrpc-epi-php.c
@@ -37,7 +37,7 @@
    +----------------------------------------------------------------------+
    | PHP Version 5                                                        |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2008 The PHP Group                                |
+   | Copyright (c) 1997-2009 The PHP Group                                |
    +----------------------------------------------------------------------+
    | This source file is subject to version 3.01 of the PHP license,      |
    | that is bundled with this package in the file LICENSE, and is        |
@@ -51,7 +51,7 @@
    +----------------------------------------------------------------------+
  */
 
-/* $Id: xmlrpc-epi-php.c,v 1.39.2.5.2.8 2007/12/31 07:20:14 sebastian Exp $ */
+/* $Id: xmlrpc-epi-php.c,v 1.39.2.5.2.13 2009/01/27 15:02:43 felipe Exp $ */
 
 /**********************************************************************
 * BUGS:                                                               *
@@ -356,65 +356,61 @@ 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) {
-		        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;
+					}
+				}
+			}
+		}
 	}
 }
 
@@ -430,199 +426,196 @@ 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;
-    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);
-    }
+	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)
 {
-   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);
+					} 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;
-                         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));
-                  }
-               }
-               break;
-            default:
-               break;
-         }
-      }
-   }
+						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));
+					}
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
    return xReturn;
 }
 
 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)
 {
-   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) {
-         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);
+	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) {
+			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;
-         default:
-            break;
-      }
-      set_zval_xmlrpc_type(elem, type);
-   }
-   return elem;
+				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;
+      	}
+		set_zval_xmlrpc_type(elem, type);
+	}
+	return elem;
 }
 
 /* {{{ proto string xmlrpc_encode_request(string method, mixed params)
@@ -665,7 +658,7 @@ PHP_FUNCTION(xmlrpc_encode_request)
 		}
 	}
 	
-	if (out.xmlrpc_out.xml_elem_opts.encoding != ENCODING_DEFAULT) {
+	if (strcmp(out.xmlrpc_out.xml_elem_opts.encoding, ENCODING_DEFAULT) != 0) {
 		efree((char *)out.xmlrpc_out.xml_elem_opts.encoding);
 	}
 }
@@ -705,30 +698,30 @@ PHP_FUNCTION(xmlrpc_encode)
 
 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])
@@ -854,29 +847,29 @@ PHP_FUNCTION(xmlrpc_server_destroy)
  */
 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));
+	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;
+	/* 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_ptr_dtor(&xmlrpc_params);
+	zval_ptr_dtor(&xmlrpc_params);
 
-   return NULL;
+	return NULL;
 }
 
 /* called by the C server when it first receives an introspection request.  We pass this on to
@@ -884,66 +877,62 @@ 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_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));
-   }
-
-   /* so we don't call the same callbacks ever again */
-   zend_hash_clean(Z_ARRVAL_P(pData->server->introspection_map));
+	zval retval, **php_function;
+	zval* callback_params[1];
+	char *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)) {
+				/* 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_dtor(&retval);
+				} else {
+					/* user func failed */
+					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error calling user introspection callback: %s()", php_function_name);
+				}
+			} else {
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid callback '%s' passed", php_function_name);
+			}
+			efree(php_function_name);
+		} else {
+			break;
+		}
+		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)
@@ -1218,70 +1207,70 @@ PHP_FUNCTION(xmlrpc_parse_method_descriptions)
 /* return a string matching a given xmlrpc type */
 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** 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)
 {
-   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;
+	const char** str_mapping = get_type_str_mapping();
+	int i;
+
+	if (str) {
+		for (i = 0; i < XMLRPC_TYPE_COUNT; i++) {
+			if (!strcmp(str_mapping[i], str)) {
+				return (XMLRPC_VALUE_TYPE) i;
+			}
+		}
+	}
+	return xmlrpc_none;
 }
 
 /* map a string to an xmlrpc vector type */
 XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str)
 {
-   const char** str_mapping = get_type_str_mapping();
-   int i;
-
-   if (str) {
-      for (i = XMLRPC_TYPE_COUNT; i < TYPE_STR_MAP_SIZE; i++) {
-         if (!strcmp(str_mapping[i], str)) {
-            return (XMLRPC_VECTOR_TYPE) (i - XMLRPC_TYPE_COUNT);
-         }
-      }
-   }
-   return xmlrpc_none;
+	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;
 }
 
 
@@ -1291,107 +1280,106 @@ XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str)
  */
 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
-    */
-   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);
-                  }
-               } else {
-			zval_ptr_dtor(&type);
-	       }
-               XMLRPC_CleanupValue(v);
-            } else {
-		zval_ptr_dtor(&type);
-	    }
-         }
-         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);
-         }
-      }
-   }
+	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);
+						}
+					} else {
+						zval_ptr_dtor(&type);
+	       			}
+               		XMLRPC_CleanupValue(v);
+            	} else {
+					zval_ptr_dtor(&type);
+	    		}
+         	} 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 bSuccess;
 }
 
 /* return xmlrpc type of a php value */
 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)) {
-         case IS_NULL:
-            type = xmlrpc_base64;
-            break;
+	XMLRPC_VALUE_TYPE type = xmlrpc_none;
+	TSRMLS_FETCH();
+
+	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) {
@@ -1406,7 +1394,6 @@ XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval** newvalue)
 			}
 		}
 	}
-
 	return type;
 }