/etc/inc/xmlrpc_client.inc - Annotate - pfSense - pfSense bugtracker

| Branch: | Tag: | Revision:

root/etc/inc/xmlrpc_client.inc @ 26732357

-            aa0d74da
+<?php
-e5
+            Bill Marquette
-            aa0d74da
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
 /**
  * PHP implementation of the XML-RPC protocol
+ *
  * This is a PEAR-ified version of Useful inc's XML-RPC for PHP.
  * It has support for HTTP transport, proxies and authentication.
+ *
  * PHP versions 4 and 5
+ *
  * LICENSE: License is granted to use or modify this software
  * ("XML-RPC for PHP") for commercial or non-commercial use provided the
  * copyright of the author is preserved in any distributed or derivative work.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESSED OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  * @category   Web Services
  * @package    XML_RPC
  * @author     Edd Dumbill <edd@usefulinc.com>
  * @author     Stig Bakken <stig@php.net>
  * @author     Martin Jansen <mj@php.net>
  * @author     Daniel Convissor <danielc@php.net>
-c22a703
+ * @copyright  1999-2001 Edd Dumbill, 2001-2006 The PHP Group
-            aa0d74da
+ * @version    CVS: $Id$
  * @link       http://pear.php.net/package/XML_RPC
  */
-b0
+/*
 	pfSense_MODULE:	utils
 */
-            aa0d74da
+            Colin Smith
 if (!function_exists('xml_parser_create')) {
-c22a703
+    include_once 'PEAR.inc';
-e5
+    PEAR::loadExtension('xml');
-            aa0d74da
+            Colin Smith
 /**#@+
  * Error constants
  */
-e5
+/**
  * Parameter values don't match parameter types
  */
 define('XML_RPC_ERROR_INVALID_TYPE', 101);
 /**
  * Parameter declared to be numeric but the values are not
  */
 define('XML_RPC_ERROR_NON_NUMERIC_FOUND', 102);
 /**
  * Communication error
  */
 define('XML_RPC_ERROR_CONNECTION_FAILED', 103);
 /**
  * The array or struct has already been started
  */
-            aa0d74da
+define('XML_RPC_ERROR_ALREADY_INITIALIZED', 104);
-e5
+/**
  * Incorrect parameters submitted
  */
 define('XML_RPC_ERROR_INCORRECT_PARAMS', 105);
 /**
  * Programming error by developer
  */
 define('XML_RPC_ERROR_PROGRAMMING', 106);
-            aa0d74da
+/**#@-*/
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_I4']
  */
 $GLOBALS['XML_RPC_I4'] = 'i4';
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_Int']
  */
 $GLOBALS['XML_RPC_Int'] = 'int';
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_Boolean']
  */
 $GLOBALS['XML_RPC_Boolean'] = 'boolean';
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_Double']
  */
 $GLOBALS['XML_RPC_Double'] = 'double';
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_String']
  */
 $GLOBALS['XML_RPC_String'] = 'string';
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_DateTime']
  */
 $GLOBALS['XML_RPC_DateTime'] = 'dateTime.iso8601';
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_Base64']
  */
 $GLOBALS['XML_RPC_Base64'] = 'base64';
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_Array']
  */
 $GLOBALS['XML_RPC_Array'] = 'array';
 /**
  * Data types
  * @global string $GLOBALS['XML_RPC_Struct']
  */
 $GLOBALS['XML_RPC_Struct'] = 'struct';
 /**
  * Data type meta-types
  * @global array $GLOBALS['XML_RPC_Types']
  */
 $GLOBALS['XML_RPC_Types'] = array(
     $GLOBALS['XML_RPC_I4']       => 1,
     $GLOBALS['XML_RPC_Int']      => 1,
     $GLOBALS['XML_RPC_Boolean']  => 1,
     $GLOBALS['XML_RPC_String']   => 1,
     $GLOBALS['XML_RPC_Double']   => 1,
     $GLOBALS['XML_RPC_DateTime'] => 1,
     $GLOBALS['XML_RPC_Base64']   => 1,
     $GLOBALS['XML_RPC_Array']    => 2,
     $GLOBALS['XML_RPC_Struct']   => 3,
 );
 /**
  * Error message numbers
  * @global array $GLOBALS['XML_RPC_err']
  */
 $GLOBALS['XML_RPC_err'] = array(
     'unknown_method'      => 1,
     'invalid_return'      => 2,
     'incorrect_params'    => 3,
     'introspect_unknown'  => 4,
     'http_error'          => 5,
-e5
+    'not_response_object' => 6,
-b6983
+    'invalid_request'     => 7,
-            aa0d74da
+);
 /**
  * Error message strings
  * @global array $GLOBALS['XML_RPC_str']
  */
 $GLOBALS['XML_RPC_str'] = array(
     'unknown_method'      => 'Unknown method',
     'invalid_return'      => 'Invalid return payload: enable debugging to examine incoming payload',
     'incorrect_params'    => 'Incorrect parameters passed to method',
     'introspect_unknown'  => 'Can\'t introspect: method unknown',
     'http_error'          => 'Didn\'t receive 200 OK from remote server.',
-e5
+    'not_response_object' => 'The requested method didn\'t return an XML_RPC_Response object.',
-b6983
+    'invalid_request'     => 'Invalid request payload',
-            aa0d74da
+);
 /**
  * Default XML encoding (ISO-8859-1, UTF-8 or US-ASCII)
  * @global string $GLOBALS['XML_RPC_defencoding']
  */
 $GLOBALS['XML_RPC_defencoding'] = 'UTF-8';
 /**
  * User error codes start at 800
  * @global int $GLOBALS['XML_RPC_erruser']
  */
 $GLOBALS['XML_RPC_erruser'] = 800;
 /**
  * XML parse error codes start at 100
  * @global int $GLOBALS['XML_RPC_errxml']
  */
 $GLOBALS['XML_RPC_errxml'] = 100;
 /**
  * Compose backslashes for escaping regexp
  * @global string $GLOBALS['XML_RPC_backslash']
  */
 $GLOBALS['XML_RPC_backslash'] = chr(92) . chr(92);
-c22a703
+/**#@+
  * Which functions to use, depending on whether mbstring is enabled or not.
  */
 if (function_exists('mb_ereg')) {
     /** @global string $GLOBALS['XML_RPC_func_ereg'] */
     $GLOBALS['XML_RPC_func_ereg'] = 'mb_eregi';
     /** @global string $GLOBALS['XML_RPC_func_ereg_replace'] */
     $GLOBALS['XML_RPC_func_ereg_replace'] = 'mb_eregi_replace';
     /** @global string $GLOBALS['XML_RPC_func_split'] */
     $GLOBALS['XML_RPC_func_split'] = 'mb_split';
 } else {
     /** @ignore */
     $GLOBALS['XML_RPC_func_ereg'] = 'eregi';
     /** @ignore */
     $GLOBALS['XML_RPC_func_ereg_replace'] = 'eregi_replace';
     /** @ignore */
     $GLOBALS['XML_RPC_func_split'] = 'split';
+}
 /**#@-*/
 /**
  * Should we automatically base64 encode strings that contain characters
  * which can cause PHP's SAX-based XML parser to break?
  * @global boolean $GLOBALS['XML_RPC_auto_base64']
  */
-            26732357
+$GLOBALS['XML_RPC_auto_base64'] = true;
-c22a703
+            Seth Mos
-b6983
+/**
  * Valid parents of XML elements
  * @global array $GLOBALS['XML_RPC_valid_parents']
  */
 $GLOBALS['XML_RPC_valid_parents'] = array(
     'BOOLEAN' => array('VALUE'),
     'I4' => array('VALUE'),
     'INT' => array('VALUE'),
     'STRING' => array('VALUE'),
     'DOUBLE' => array('VALUE'),
     'DATETIME.ISO8601' => array('VALUE'),
     'BASE64' => array('VALUE'),
     'ARRAY' => array('VALUE'),
     'STRUCT' => array('VALUE'),
     'PARAM' => array('PARAMS'),
     'METHODNAME' => array('METHODCALL'),
     'PARAMS' => array('METHODCALL', 'METHODRESPONSE'),
     'MEMBER' => array('STRUCT'),
     'NAME' => array('MEMBER'),
     'DATA' => array('ARRAY'),
     'FAULT' => array('METHODRESPONSE'),
     'VALUE' => array('MEMBER', 'DATA', 'PARAM', 'FAULT'),
 );
-            aa0d74da
+/**
  * Stores state during parsing
+ *
  * quick explanation of components:
  *   + ac     = accumulates values
  *   + qt     = decides if quotes are needed for evaluation
  *   + cm     = denotes struct or array (comma needed)
  *   + isf    = indicates a fault
  *   + lv     = indicates "looking for a value": implements the logic
  *               to allow values with no types to be strings
  *   + params = stores parameters in method calls
  *   + method = stores method name
+ *
  * @global array $GLOBALS['XML_RPC_xh']
  */
 $GLOBALS['XML_RPC_xh'] = array();
 /**
  * Start element handler for the XML parser
+ *
  * @return void
  */
 function XML_RPC_se($parser_resource, $name, $attrs)
+{
-c22a703
+    global $XML_RPC_xh, $XML_RPC_valid_parents;
-            aa0d74da
+    $parser = (int) $parser_resource;
-b6983
+    // if invalid xmlrpc already detected, skip all processing
     if ($XML_RPC_xh[$parser]['isf'] >= 2) {
         return;
+    }
     // check for correct element nesting
     // top level element can only be of 2 types
     if (count($XML_RPC_xh[$parser]['stack']) == 0) {
         if ($name != 'METHODRESPONSE' && $name != 'METHODCALL') {
             $XML_RPC_xh[$parser]['isf'] = 2;
             $XML_RPC_xh[$parser]['isf_reason'] = 'missing top level xmlrpc element';
             return;
+        }
     } else {
         // not top level element: see if parent is OK
         if (!in_array($XML_RPC_xh[$parser]['stack'][0], $XML_RPC_valid_parents[$name])) {
-c22a703
+            $name = $GLOBALS['XML_RPC_func_ereg_replace']('[^a-zA-Z0-9._-]', '', $name);
-b6983
+            $XML_RPC_xh[$parser]['isf'] = 2;
             $XML_RPC_xh[$parser]['isf_reason'] = "xmlrpc element $name cannot be child of {$XML_RPC_xh[$parser]['stack'][0]}";
             return;
+        }
+    }
-            aa0d74da
+    switch ($name) {
     case 'STRUCT':
-b6983
+        $XML_RPC_xh[$parser]['cm']++;
         // turn quoting off
         $XML_RPC_xh[$parser]['qt'] = 0;
         $cur_val = array();
         $cur_val['value'] = array();
         $cur_val['members'] = 1;
         array_unshift($XML_RPC_xh[$parser]['valuestack'], $cur_val);
         break;
-            aa0d74da
+    case 'ARRAY':
         $XML_RPC_xh[$parser]['cm']++;
-b6983
+            Colin Smith
         // turn quoting off
-            aa0d74da
+        $XML_RPC_xh[$parser]['qt'] = 0;
-b6983
+            Colin Smith
         $cur_val = array();
         $cur_val['value'] = array();
         $cur_val['members'] = 0;
         array_unshift($XML_RPC_xh[$parser]['valuestack'], $cur_val);
-            aa0d74da
+        break;
     case 'NAME':
         $XML_RPC_xh[$parser]['ac'] = '';
         break;
     case 'FAULT':
         $XML_RPC_xh[$parser]['isf'] = 1;
         break;
     case 'PARAM':
-b6983
+        $XML_RPC_xh[$parser]['valuestack'] = array();
-            aa0d74da
+        break;
     case 'VALUE':
         $XML_RPC_xh[$parser]['lv'] = 1;
-c22a703
+        $XML_RPC_xh[$parser]['vt'] = $GLOBALS['XML_RPC_String'];
-            aa0d74da
+        $XML_RPC_xh[$parser]['ac'] = '';
         $XML_RPC_xh[$parser]['qt'] = 0;
         // look for a value: if this is still 1 by the
         // time we reach the first data segment then the type is string
         // by implication and we need to add in a quote
         break;
     case 'I4':
     case 'INT':
     case 'STRING':
     case 'BOOLEAN':
     case 'DOUBLE':
     case 'DATETIME.ISO8601':
     case 'BASE64':
         $XML_RPC_xh[$parser]['ac'] = ''; // reset the accumulator
         if ($name == 'DATETIME.ISO8601' || $name == 'STRING') {
             $XML_RPC_xh[$parser]['qt'] = 1;
             if ($name == 'DATETIME.ISO8601') {
-c22a703
+                $XML_RPC_xh[$parser]['vt'] = $GLOBALS['XML_RPC_DateTime'];
-            aa0d74da
+            Colin Smith
         } elseif ($name == 'BASE64') {
             $XML_RPC_xh[$parser]['qt'] = 2;
         } else {
             // No quoting is required here -- but
             // at the end of the element we must check
             // for data format errors.
             $XML_RPC_xh[$parser]['qt'] = 0;
+        }
         break;
     case 'MEMBER':
         $XML_RPC_xh[$parser]['ac'] = '';
-b6983
+        break;
     case 'DATA':
     case 'METHODCALL':
     case 'METHODNAME':
     case 'METHODRESPONSE':
     case 'PARAMS':
         // valid elements that add little to processing
         break;
-            aa0d74da
+            Colin Smith
-b6983
+            Colin Smith
     // Save current element to stack
     array_unshift($XML_RPC_xh[$parser]['stack'], $name);
-            aa0d74da
+    if ($name != 'VALUE') {
         $XML_RPC_xh[$parser]['lv'] = 0;
+    }
+}
 /**
  * End element handler for the XML parser
+ *
  * @return void
  */
 function XML_RPC_ee($parser_resource, $name)
+{
-c22a703
+    global $XML_RPC_xh;
-            aa0d74da
+    $parser = (int) $parser_resource;
-b6983
+    if ($XML_RPC_xh[$parser]['isf'] >= 2) {
         return;
+    }
     // push this element from stack
     // NB: if XML validates, correct opening/closing is guaranteed and
     // we do not have to check for $name == $curr_elem.
     // we also checked for proper nesting at start of elements...
     $curr_elem = array_shift($XML_RPC_xh[$parser]['stack']);
-            aa0d74da
+    switch ($name) {
     case 'STRUCT':
     case 'ARRAY':
-b6983
+    $cur_val = array_shift($XML_RPC_xh[$parser]['valuestack']);
     $XML_RPC_xh[$parser]['value'] = $cur_val['value'];
-            aa0d74da
+        $XML_RPC_xh[$parser]['vt'] = strtolower($name);
         $XML_RPC_xh[$parser]['cm']--;
         break;
     case 'NAME':
-b6983
+    $XML_RPC_xh[$parser]['valuestack'][0]['name'] = $XML_RPC_xh[$parser]['ac'];
-            aa0d74da
+        break;
     case 'BOOLEAN':
         // special case here: we translate boolean 1 or 0 into PHP
         // constants true or false
         if ($XML_RPC_xh[$parser]['ac'] == '1') {
             $XML_RPC_xh[$parser]['ac'] = 'true';
         } else {
             $XML_RPC_xh[$parser]['ac'] = 'false';
+        }
         $XML_RPC_xh[$parser]['vt'] = strtolower($name);
         // Drop through intentionally.
     case 'I4':
     case 'INT':
     case 'STRING':
     case 'DOUBLE':
     case 'DATETIME.ISO8601':
     case 'BASE64':
         if ($XML_RPC_xh[$parser]['qt'] == 1) {
             // we use double quotes rather than single so backslashification works OK
-b6983
+            $XML_RPC_xh[$parser]['value'] = $XML_RPC_xh[$parser]['ac'];
-            aa0d74da
+        } elseif ($XML_RPC_xh[$parser]['qt'] == 2) {
-b6983
+            $XML_RPC_xh[$parser]['value'] = base64_decode($XML_RPC_xh[$parser]['ac']);
-            aa0d74da
+        } elseif ($name == 'BOOLEAN') {
-b6983
+            $XML_RPC_xh[$parser]['value'] = $XML_RPC_xh[$parser]['ac'];
-            aa0d74da
+        } else {
             // we have an I4, INT or a DOUBLE
             // we must check that only 0123456789-.<space> are characters here
-c22a703
+            if (!$GLOBALS['XML_RPC_func_ereg']("^[+-]?[0123456789 \t\.]+$", $XML_RPC_xh[$parser]['ac'])) {
-            aa0d74da
+                XML_RPC_Base::raiseError('Non-numeric value received in INT or DOUBLE',
                                          XML_RPC_ERROR_NON_NUMERIC_FOUND);
-b6983
+                $XML_RPC_xh[$parser]['value'] = XML_RPC_ERROR_NON_NUMERIC_FOUND;
-            aa0d74da
+            } else {
                 // it's ok, add it on
-b6983
+                $XML_RPC_xh[$parser]['value'] = $XML_RPC_xh[$parser]['ac'];
-            aa0d74da
+            Colin Smith
+        }
         $XML_RPC_xh[$parser]['ac'] = '';
         $XML_RPC_xh[$parser]['qt'] = 0;
         $XML_RPC_xh[$parser]['lv'] = 3; // indicate we've found a value
         break;
     case 'VALUE':
-c22a703
+        if ($XML_RPC_xh[$parser]['vt'] == $GLOBALS['XML_RPC_String']) {
-            b755666f
+            if (strlen($XML_RPC_xh[$parser]['ac']) > 0) {
                 $XML_RPC_xh[$parser]['value'] = $XML_RPC_xh[$parser]['ac'];
             } elseif ($XML_RPC_xh[$parser]['lv'] == 1) {
                 // The <value> element was empty.
                 $XML_RPC_xh[$parser]['value'] = '';
+            }
-            aa0d74da
+            Colin Smith
-b6983
+        $temp = new XML_RPC_Value($XML_RPC_xh[$parser]['value'], $XML_RPC_xh[$parser]['vt']);
         $cur_val = array_shift($XML_RPC_xh[$parser]['valuestack']);
         if (is_array($cur_val)) {
             if ($cur_val['members']==0) {
                 $cur_val['value'][] = $temp;
             } else {
                 $XML_RPC_xh[$parser]['value'] = $temp;
+            }
             array_unshift($XML_RPC_xh[$parser]['valuestack'], $cur_val);
         } else {
             $XML_RPC_xh[$parser]['value'] = $temp;
-            aa0d74da
+            Colin Smith
         break;
     case 'MEMBER':
         $XML_RPC_xh[$parser]['ac'] = '';
         $XML_RPC_xh[$parser]['qt'] = 0;
-b6983
+            Colin Smith
         $cur_val = array_shift($XML_RPC_xh[$parser]['valuestack']);
         if (is_array($cur_val)) {
             if ($cur_val['members']==1) {
                 $cur_val['value'][$cur_val['name']] = $XML_RPC_xh[$parser]['value'];
+            }
             array_unshift($XML_RPC_xh[$parser]['valuestack'], $cur_val);
+        }
-            aa0d74da
+        break;
     case 'DATA':
         $XML_RPC_xh[$parser]['ac'] = '';
         $XML_RPC_xh[$parser]['qt'] = 0;
         break;
     case 'PARAM':
-b6983
+        $XML_RPC_xh[$parser]['params'][] = $XML_RPC_xh[$parser]['value'];
-            aa0d74da
+        break;
     case 'METHODNAME':
-e5
+    case 'RPCMETHODNAME':
-c22a703
+        $XML_RPC_xh[$parser]['method'] = $GLOBALS['XML_RPC_func_ereg_replace']("^[\n\r\t ]+", '',
-            aa0d74da
+                                                      $XML_RPC_xh[$parser]['ac']);
         break;
+    }
     // if it's a valid type name, set the type
-c22a703
+    if (isset($GLOBALS['XML_RPC_Types'][strtolower($name)])) {
-            aa0d74da
+        $XML_RPC_xh[$parser]['vt'] = strtolower($name);
+    }
+}
 /**
  * Character data handler for the XML parser
+ *
  * @return void
  */
 function XML_RPC_cd($parser_resource, $data)
+{
     global $XML_RPC_xh, $XML_RPC_backslash;
-c22a703
+            Seth Mos
-            aa0d74da
+    $parser = (int) $parser_resource;
     if ($XML_RPC_xh[$parser]['lv'] != 3) {
         // "lookforvalue==3" means that we've found an entire value
         // and should discard any further character data
         if ($XML_RPC_xh[$parser]['lv'] == 1) {
             // if we've found text and we're just in a <value> then
             // turn quoting on, as this will be a string
             $XML_RPC_xh[$parser]['qt'] = 1;
             // and say we've found a value
             $XML_RPC_xh[$parser]['lv'] = 2;
+        }
         // replace characters that eval would
         // do special things with
         if (!isset($XML_RPC_xh[$parser]['ac'])) {
             $XML_RPC_xh[$parser]['ac'] = '';
+        }
-b6983
+        $XML_RPC_xh[$parser]['ac'] .= $data;
-            aa0d74da
+            Colin Smith
+}
 /**
-e5
+ * The common methods and properties for all of the XML_RPC classes
-            aa0d74da
+            Colin Smith
  * @category   Web Services
  * @package    XML_RPC
  * @author     Edd Dumbill <edd@usefulinc.com>
  * @author     Stig Bakken <stig@php.net>
  * @author     Martin Jansen <mj@php.net>
-e5
+ * @author     Daniel Convissor <danielc@php.net>
-c22a703
+ * @copyright  1999-2001 Edd Dumbill, 2001-2006 The PHP Group
  * @version    Release: 1.5.1
-            aa0d74da
+ * @link       http://pear.php.net/package/XML_RPC
  */
 class XML_RPC_Base {
     /**
      * PEAR Error handling
+     *
      * @return object  PEAR_Error object
      */
     function raiseError($msg, $code)
+    {
-            dbfda089
+        include_once 'PEAR.inc';
-            aa0d74da
+        if (is_object(@$this)) {
             return PEAR::raiseError(get_class($this) . ': ' . $msg, $code);
         } else {
             return PEAR::raiseError('XML_RPC: ' . $msg, $code);
+        }
+    }
     /**
      * Tell whether something is a PEAR_Error object
+     *
      * @param mixed $value  the item to check
+     *
      * @return bool  whether $value is a PEAR_Error object or not
+     *
      * @access public
      */
     function isError($value)
+    {
         return is_a($value, 'PEAR_Error');
+    }
+}
 /**
-e5
+ * The methods and properties for submitting XML RPC requests
-            aa0d74da
+            Colin Smith
  * @category   Web Services
  * @package    XML_RPC
  * @author     Edd Dumbill <edd@usefulinc.com>
  * @author     Stig Bakken <stig@php.net>
  * @author     Martin Jansen <mj@php.net>
  * @author     Daniel Convissor <danielc@php.net>
-c22a703
+ * @copyright  1999-2001 Edd Dumbill, 2001-2006 The PHP Group
  * @version    Release: 1.5.1
-            aa0d74da
+ * @link       http://pear.php.net/package/XML_RPC
  */
 class XML_RPC_Client extends XML_RPC_Base {
     /**
      * The path and name of the RPC server script you want the request to go to
      * @var string
      */
     var $path = '';
     /**
      * The name of the remote server to connect to
      * @var string
      */
     var $server = '';
     /**
      * The protocol to use in contacting the remote server
      * @var string
      */
     var $protocol = 'http://';
     /**
      * The port for connecting to the remote server
+     *
      * The default is 80 for http:// connections
      * and 443 for https:// and ssl:// connections.
+     *
      * @var integer
      */
     var $port = 80;
     /**
      * A user name for accessing the RPC server
      * @var string
      * @see XML_RPC_Client::setCredentials()
      */
     var $username = '';
     /**
      * A password for accessing the RPC server
      * @var string
      * @see XML_RPC_Client::setCredentials()
      */
     var $password = '';
     /**
      * The name of the proxy server to use, if any
      * @var string
      */
     var $proxy = '';
     /**
      * The protocol to use in contacting the proxy server, if any
      * @var string
      */
     var $proxy_protocol = 'http://';
     /**
      * The port for connecting to the proxy server
+     *
      * The default is 8080 for http:// connections
      * and 443 for https:// and ssl:// connections.
+     *
      * @var integer
      */
     var $proxy_port = 8080;
     /**
      * A user name for accessing the proxy server
      * @var string
      */
     var $proxy_user = '';
     /**
      * A password for accessing the proxy server
      * @var string
      */
     var $proxy_pass = '';
     /**
      * The error number, if any
      * @var integer
      */
     var $errno = 0;
     /**
      * The error message, if any
      * @var string
      */
-b6983
+    var $errstr = '';
-            aa0d74da
+            Colin Smith
     /**
      * The current debug mode (1 = on, 0 = off)
      * @var integer
      */
     var $debug = 0;
-e5
+    /**
      * The HTTP headers for the current request.
      * @var string
      */
     var $headers = '';
-            aa0d74da
+            Colin Smith
     /**
      * Sets the object's properties
+     *
      * @param string  $path        the path and name of the RPC server script
      *                              you want the request to go to
      * @param string  $server      the URL of the remote server to connect to.
      *                              If this parameter doesn't specify a
      *                              protocol and $port is 443, ssl:// is
      *                              assumed.
      * @param integer $port        a port for connecting to the remote server.
      *                              Defaults to 80 for http:// connections and
      *                              443 for https:// and ssl:// connections.
      * @param string  $proxy       the URL of the proxy server to use, if any.
      *                              If this parameter doesn't specify a
      *                              protocol and $port is 443, ssl:// is
      *                              assumed.
      * @param integer $proxy_port  a port for connecting to the remote server.
      *                              Defaults to 8080 for http:// connections and
      *                              443 for https:// and ssl:// connections.
      * @param string  $proxy_user  a user name for accessing the proxy server
      * @param string  $proxy_pass  a password for accessing the proxy server
+     *
      * @return void
      */
     function XML_RPC_Client($path, $server, $port = 0,
                             $proxy = '', $proxy_port = 0,
                             $proxy_user = '', $proxy_pass = '')
+    {
         $this->path       = $path;
         $this->proxy_user = $proxy_user;
         $this->proxy_pass = $proxy_pass;
-c22a703
+        $GLOBALS['XML_RPC_func_ereg']('^(http://|https://|ssl://)?(.*)$', $server, $match);
-            aa0d74da
+        if ($match[1] == '') {
             if ($port == 443) {
                 $this->server   = $match[2];
                 $this->protocol = 'ssl://';
                 $this->port     = 443;
             } else {
                 $this->server = $match[2];
                 if ($port) {
                     $this->port = $port;
+                }
+            }
         } elseif ($match[1] == 'http://') {
             $this->server = $match[2];
             if ($port) {
                 $this->port = $port;
+            }
         } else {
             $this->server   = $match[2];
             $this->protocol = 'ssl://';
             if ($port) {
                 $this->port = $port;
             } else {
                 $this->port = 443;
+            }
+        }
         if ($proxy) {
-c22a703
+            $GLOBALS['XML_RPC_func_ereg']('^(http://|https://|ssl://)?(.*)$', $proxy, $match);
-            aa0d74da
+            if ($match[1] == '') {
                 if ($proxy_port == 443) {
                     $this->proxy          = $match[2];
                     $this->proxy_protocol = 'ssl://';
                     $this->proxy_port     = 443;
                 } else {
                     $this->proxy = $match[2];
                     if ($proxy_port) {
                         $this->proxy_port = $proxy_port;
+                    }
+                }
             } elseif ($match[1] == 'http://') {
                 $this->proxy = $match[2];
                 if ($proxy_port) {
                     $this->proxy_port = $proxy_port;
+                }
             } else {
                 $this->proxy          = $match[2];
                 $this->proxy_protocol = 'ssl://';
                 if ($proxy_port) {
                     $this->proxy_port = $proxy_port;
                 } else {
                     $this->proxy_port = 443;
+                }
+            }
+        }
+    }
     /**
      * Change the current debug mode
+     *
      * @param int $in  where 1 = on, 0 = off
+     *
      * @return void
      */
     function setDebug($in)
+    {
         if ($in) {
             $this->debug = 1;
         } else {
             $this->debug = 0;
+        }
+    }
-c22a703
+    /**
      * Sets whether strings that contain characters which may cause PHP's
      * SAX-based XML parser to break should be automatically base64 encoded
+     *
      * This is is a workaround for systems that don't have PHP's mbstring
      * extension available.
+     *
      * @param int $in  where 1 = on, 0 = off
+     *
      * @return void
      */
     function setAutoBase64($in)
+    {
         if ($in) {
             $GLOBALS['XML_RPC_auto_base64'] = true;
         } else {
             $GLOBALS['XML_RPC_auto_base64'] = false;
+        }
+    }
-            aa0d74da
+    /**
      * Set username and password properties for connecting to the RPC server
+     *
      * @param string $u  the user name
      * @param string $p  the password
+     *
      * @return void
+     *
      * @see XML_RPC_Client::$username, XML_RPC_Client::$password
      */
     function setCredentials($u, $p)
+    {
         $this->username = $u;
         $this->password = $p;
+    }
     /**
      * Transmit the RPC request via HTTP 1.0 protocol
+     *
      * @param object $msg       the XML_RPC_Message object
      * @param int    $timeout   how many seconds to wait for the request
+     *
      * @return object  an XML_RPC_Response object.  0 is returned if any
      *                  problems happen.
+     *
      * @see XML_RPC_Message, XML_RPC_Client::XML_RPC_Client(),
      *      XML_RPC_Client::setCredentials()
      */
     function send($msg, $timeout = 0)
+    {
-b6983
+        if (!is_a($msg, 'XML_RPC_Message')) {
-e5
+            $this->errstr = 'send()\'s $msg parameter must be an'
                           . ' XML_RPC_Message object.';
             $this->raiseError($this->errstr, XML_RPC_ERROR_PROGRAMMING);
             return 0;
+        }
-            aa0d74da
+        $msg->debug = $this->debug;
         return $this->sendPayloadHTTP10($msg, $this->server, $this->port,
                                         $timeout, $this->username,
                                         $this->password);
+    }
     /**
      * Transmit the RPC request via HTTP 1.0 protocol
+     *
      * Requests should be sent using XML_RPC_Client send() rather than
      * calling this method directly.
+     *
      * @param object $msg       the XML_RPC_Message object
      * @param string $server    the server to send the request to
      * @param int    $port      the server port send the request to
      * @param int    $timeout   how many seconds to wait for the request
      *                           before giving up
      * @param string $username  a user name for accessing the RPC server
      * @param string $password  a password for accessing the RPC server
+     *
      * @return object  an XML_RPC_Response object.  0 is returned if any
      *                  problems happen.
+     *
-e5
+     * @access protected
-            aa0d74da
+     * @see XML_RPC_Client::send()
      */
     function sendPayloadHTTP10($msg, $server, $port, $timeout = 0,
                                $username = '', $password = '')
+    {
         /*
          * If we're using a proxy open a socket to the proxy server
          * instead to the xml-rpc server
          */
         if ($this->proxy) {
             if ($this->proxy_protocol == 'http://') {
                 $protocol = '';
             } else {
                 $protocol = $this->proxy_protocol;
+            }
             if ($timeout > 0) {
                 $fp = @fsockopen($protocol . $this->proxy, $this->proxy_port,
                                  $this->errno, $this->errstr, $timeout);
             } else {
                 $fp = @fsockopen($protocol . $this->proxy, $this->proxy_port,
                                  $this->errno, $this->errstr);
+            }
         } else {
             if ($this->protocol == 'http://') {
                 $protocol = '';
             } else {
                 $protocol = $this->protocol;
+            }
             if ($timeout > 0) {
                 $fp = @fsockopen($protocol . $server, $port,
                                  $this->errno, $this->errstr, $timeout);
             } else {
                 $fp = @fsockopen($protocol . $server, $port,
                                  $this->errno, $this->errstr);
+            }
+        }
         /*
          * Just raising the error without returning it is strange,
          * but keep it here for backwards compatibility.
          */
         if (!$fp && $this->proxy) {
             $this->raiseError('Connection to proxy server '
                               . $this->proxy . ':' . $this->proxy_port
                               . ' failed. ' . $this->errstr,
                               XML_RPC_ERROR_CONNECTION_FAILED);
             return 0;
         } elseif (!$fp) {
             $this->raiseError('Connection to RPC server '
                               . $server . ':' . $port
                               . ' failed. ' . $this->errstr,
                               XML_RPC_ERROR_CONNECTION_FAILED);
             return 0;
+        }
-e5
+        if ($timeout) {
-b6983
+            /*
              * Using socket_set_timeout() because stream_set_timeout()
              * was introduced in 4.3.0, but we need to support 4.2.0.
              */
             socket_set_timeout($fp, $timeout);
-e5
+            Bill Marquette
         // Pre-emptive BC hacks for fools calling sendPayloadHTTP10() directly
         if ($username != $this->username) {
             $this->setCredentials($username, $password);
+        }
-            aa0d74da
+        // Only create the payload if it was not created previously
         if (empty($msg->payload)) {
             $msg->createPayload();
+        }
-e5
+        $this->createHeaders($msg);
-            aa0d74da
+            Colin Smith
-e5
+        $op  = $this->headers . "\r\n\r\n";
         $op .= $msg->payload;
         if (!fputs($fp, $op, strlen($op))) {
             $this->errstr = 'Write error';
             return 0;
-            aa0d74da
+            Colin Smith
-e5
+        $resp = $msg->parseResponseFile($fp);
-b6983
+        $meta = socket_get_status($fp);
-e5
+        if ($meta['timed_out']) {
             fclose($fp);
             $this->errstr = 'RPC server did not send response before timeout.';
             $this->raiseError($this->errstr, XML_RPC_ERROR_CONNECTION_FAILED);
             return 0;
+        }
         fclose($fp);
         return $resp;
+    }
-            aa0d74da
+            Colin Smith
-e5
+    /**
      * Determines the HTTP headers and puts it in the $headers property
+     *
      * @param object $msg       the XML_RPC_Message object
+     *
      * @return boolean  TRUE if okay, FALSE if the message payload isn't set.
+     *
      * @access protected
      */
     function createHeaders($msg)
+    {
         if (empty($msg->payload)) {
             return false;
+        }
-            aa0d74da
+        if ($this->proxy) {
-e5
+            $this->headers = 'POST ' . $this->protocol . $this->server;
-            aa0d74da
+            if ($this->proxy_port) {
-e5
+                $this->headers .= ':' . $this->port;
-            aa0d74da
+            Colin Smith
         } else {
-e5
+           $this->headers = 'POST ';
-            aa0d74da
+            Colin Smith
-e5
+        $this->headers .= $this->path. " HTTP/1.0\r\n";
-b6983
+            Colin Smith
-e5
+        $this->headers .= "User-Agent: PEAR XML_RPC\r\n";
         $this->headers .= 'Host: ' . $this->server . "\r\n";
         if ($this->proxy && $this->proxy_user) {
             $this->headers .= 'Proxy-Authorization: Basic '
                      . base64_encode("$this->proxy_user:$this->proxy_pass")
                      . "\r\n";
-            aa0d74da
+            Colin Smith
-e5
+        // thanks to Grant Rauscher <grant7@firstworld.net> for this
         if ($this->username) {
             $this->headers .= 'Authorization: Basic '
                      . base64_encode("$this->username:$this->password")
                      . "\r\n";
-            aa0d74da
+            Colin Smith
-e5
+            Bill Marquette
         $this->headers .= "Content-Type: text/xml\r\n";
         $this->headers .= 'Content-Length: ' . strlen($msg->payload);
         return true;
-            aa0d74da
+            Colin Smith
+}
 /**
-e5
+ * The methods and properties for interpreting responses to XML RPC requests
-            aa0d74da
+            Colin Smith
  * @category   Web Services
  * @package    XML_RPC
  * @author     Edd Dumbill <edd@usefulinc.com>
  * @author     Stig Bakken <stig@php.net>
  * @author     Martin Jansen <mj@php.net>
-e5
+ * @author     Daniel Convissor <danielc@php.net>
-c22a703
+ * @copyright  1999-2001 Edd Dumbill, 2001-2006 The PHP Group
  * @version    Release: 1.5.1
-            aa0d74da
+ * @link       http://pear.php.net/package/XML_RPC
  */
 class XML_RPC_Response extends XML_RPC_Base
+{
     var $xv;
     var $fn;
     var $fs;
     var $hdrs;
     /**
      * @return void
      */
     function XML_RPC_Response($val, $fcode = 0, $fstr = '')
+    {
         if ($fcode != 0) {
             $this->fn = $fcode;
             $this->fs = htmlspecialchars($fstr);
         } else {
             $this->xv = $val;
+        }
+    }
     /**
      * @return int  the error code
      */
     function faultCode()
+    {
         if (isset($this->fn)) {
             return $this->fn;
         } else {
             return 0;
+        }
+    }
     /**
      * @return string  the error string
      */
     function faultString()
+    {
         return $this->fs;
+    }
     /**
      * @return mixed  the value
      */
     function value()
+    {
         return $this->xv;
+    }
     /**
      * @return string  the error message in XML format
      */
     function serialize()
+    {
         $rs = "<methodResponse>\n";
         if ($this->fn) {
             $rs .= "<fault>
   <value>
     <struct>
       <member>
         <name>faultCode</name>
         <value><int>" . $this->fn . "</int></value>
       </member>
       <member>
         <name>faultString</name>
         <value><string>" . $this->fs . "</string></value>
       </member>
     </struct>
   </value>
 </fault>";
         } else {
             $rs .= "<params>\n<param>\n" . $this->xv->serialize() .
         "</param>\n</params>";
+        }
         $rs .= "\n</methodResponse>";
         return $rs;
+    }
+}
 /**
-e5
+ * The methods and properties for composing XML RPC messages
-            aa0d74da
+            Colin Smith
  * @category   Web Services
  * @package    XML_RPC
  * @author     Edd Dumbill <edd@usefulinc.com>
  * @author     Stig Bakken <stig@php.net>
  * @author     Martin Jansen <mj@php.net>
  * @author     Daniel Convissor <danielc@php.net>
-c22a703
+ * @copyright  1999-2001 Edd Dumbill, 2001-2006 The PHP Group
  * @version    Release: 1.5.1
-            aa0d74da
+ * @link       http://pear.php.net/package/XML_RPC
  */
 class XML_RPC_Message extends XML_RPC_Base
+{
-c22a703
+    /**
      * Should the payload's content be passed through mb_convert_encoding()?
+     *
      * @see XML_RPC_Message::setConvertPayloadEncoding()
      * @since Property available since Release 1.5.1
      * @var boolean
      */
     var $convert_payload_encoding = false;
-            aa0d74da
+    /**
      * The current debug mode (1 = on, 0 = off)
      * @var integer
      */
     var $debug = 0;
     /**
      * The encoding to be used for outgoing messages
+     *
      * Defaults to the value of <var>$GLOBALS['XML_RPC_defencoding']</var>
+     *
      * @var string
      * @see XML_RPC_Message::setSendEncoding(),
      *      $GLOBALS['XML_RPC_defencoding'], XML_RPC_Message::xml_header()
      */
     var $send_encoding = '';
     /**
      * The method presently being evaluated
      * @var string
      */
     var $methodname = '';
     /**
      * @var array
      */
     var $params = array();
     /**
      * The XML message being generated
      * @var string
      */
     var $payload = '';
-c22a703
+    /**
      * Should extra line breaks be removed from the payload?
      * @since Property available since Release 1.4.6
      * @var boolean
      */
     var $remove_extra_lines = true;
     /**
      * The XML response from the remote server
      * @since Property available since Release 1.4.6
      * @var string
      */
     var $response_payload = '';
-            aa0d74da
+    /**
      * @return void
      */
     function XML_RPC_Message($meth, $pars = 0)
+    {
         $this->methodname = $meth;
         if (is_array($pars) && sizeof($pars) > 0) {
             for ($i = 0; $i < sizeof($pars); $i++) {
                 $this->addParam($pars[$i]);
+            }
+        }
+    }
     /**
      * Produces the XML declaration including the encoding attribute
+     *
      * The encoding is determined by this class' <var>$send_encoding</var>
      * property.  If the <var>$send_encoding</var> property is not set, use
      * <var>$GLOBALS['XML_RPC_defencoding']</var>.
+     *
      * @return string  the XML declaration and <methodCall> element
+     *
      * @see XML_RPC_Message::setSendEncoding(),
      *      XML_RPC_Message::$send_encoding, $GLOBALS['XML_RPC_defencoding']
      */
     function xml_header()
+    {
         global $XML_RPC_defencoding;
-c22a703
+            Seth Mos
-            aa0d74da
+        if (!$this->send_encoding) {
             $this->send_encoding = $XML_RPC_defencoding;
+        }
         return '<?xml version="1.0" encoding="' . $this->send_encoding . '"?>'
                . "\n<methodCall>\n";
+    }
     /**
      * @return string  the closing </methodCall> tag
      */
     function xml_footer()
+    {
         return "</methodCall>\n";
+    }
     /**
-c22a703
+     * Fills the XML_RPC_Message::$payload property
+     *
      * Part of the process makes sure all line endings are in DOS format
      * (CRLF), which is probably required by specifications.
+     *
      * If XML_RPC_Message::setConvertPayloadEncoding() was set to true,
      * the payload gets passed through mb_convert_encoding()
      * to ensure the payload matches the encoding set in the
      * XML declaration.  The encoding type can be manually set via
      * XML_RPC_Message::setSendEncoding().
+     *
-            aa0d74da
+     * @return void
+     *
      * @uses XML_RPC_Message::xml_header(), XML_RPC_Message::xml_footer()
-c22a703
+     * @see XML_RPC_Message::setSendEncoding(), $GLOBALS['XML_RPC_defencoding'],
      *      XML_RPC_Message::setConvertPayloadEncoding()
-            aa0d74da
+     */
     function createPayload()
+    {
         $this->payload = $this->xml_header();
         $this->payload .= '<methodName>' . $this->methodname . "</methodName>\n";
         $this->payload .= "<params>\n";
         for ($i = 0; $i < sizeof($this->params); $i++) {
             $p = $this->params[$i];
             $this->payload .= "<param>\n" . $p->serialize() . "</param>\n";
+        }
         $this->payload .= "</params>\n";
         $this->payload .= $this->xml_footer();
-c22a703
+        if ($this->remove_extra_lines) {
             $this->payload = $GLOBALS['XML_RPC_func_ereg_replace']("[\r\n]+", "\r\n", $this->payload);
         } else {
             $this->payload = $GLOBALS['XML_RPC_func_ereg_replace']("\r\n|\n|\r|\n\r", "\r\n", $this->payload);
+        }
         if ($this->convert_payload_encoding) {
             $this->payload = mb_convert_encoding($this->payload, $this->send_encoding);
+        }
-            aa0d74da
+            Colin Smith
     /**
      * @return string  the name of the method
      */
     function method($meth = '')
+    {
         if ($meth != '') {
             $this->methodname = $meth;
+        }
         return $this->methodname;
+    }
     /**
      * @return string  the payload
      */
     function serialize()
+    {
         $this->createPayload();
         return $this->payload;
+    }
     /**
      * @return void
      */
     function addParam($par)
+    {
         $this->params[] = $par;
+    }
     /**
-e5
+     * Obtains an XML_RPC_Value object for the given parameter
+     *
      * @param int $i  the index number of the parameter to obtain
+     *
      * @return object  the XML_RPC_Value object.
      *                  If the parameter doesn't exist, an XML_RPC_Response object.
+     *
      * @since Returns XML_RPC_Response object on error since Release 1.3.0
-            aa0d74da
+     */
     function getParam($i)
+    {
-e5
+        global $XML_RPC_err, $XML_RPC_str;
         if (isset($this->params[$i])) {
             return $this->params[$i];
         } else {
             $this->raiseError('The submitted request did not contain this parameter',
                               XML_RPC_ERROR_INCORRECT_PARAMS);
             return new XML_RPC_Response(0, $XML_RPC_err['incorrect_params'],
                                         $XML_RPC_str['incorrect_params']);
+        }
-            aa0d74da
+            Colin Smith
     /**
      * @return int  the number of parameters
      */
     function getNumParams()
+    {
         return sizeof($this->params);
+    }
-c22a703
+    /**
      * Sets whether the payload's content gets passed through
      * mb_convert_encoding()
+     *
      * Returns PEAR_ERROR object if mb_convert_encoding() isn't available.
+     *
      * @param int $in  where 1 = on, 0 = off
+     *
      * @return void
+     *
      * @see XML_RPC_Message::setSendEncoding()
      * @since Method available since Release 1.5.1
      */
     function setConvertPayloadEncoding($in)
+    {
         if ($in && !function_exists('mb_convert_encoding')) {
             return $this->raiseError('mb_convert_encoding() is not available',
                               XML_RPC_ERROR_PROGRAMMING);
+        }
         $this->convert_payload_encoding = $in;
+    }
-            aa0d74da
+    /**
      * Sets the XML declaration's encoding attribute
+     *
      * @param string $type  the encoding type (ISO-8859-1, UTF-8 or US-ASCII)
+     *
      * @return void
+     *
-c22a703
+     * @see XML_RPC_Message::setConvertPayloadEncoding(), XML_RPC_Message::xml_header()
-            aa0d74da
+     * @since Method available since Release 1.2.0
      */
     function setSendEncoding($type)
+    {
         $this->send_encoding = $type;
+    }
     /**
      * Determine the XML's encoding via the encoding attribute
      * in the XML declaration
+     *
      * If the encoding parameter is not set or is not ISO-8859-1, UTF-8
      * or US-ASCII, $XML_RPC_defencoding will be returned.
+     *
      * @param string $data  the XML that will be parsed
+     *
      * @return string  the encoding to be used
+     *
      * @link   http://php.net/xml_parser_create
      * @since  Method available since Release 1.2.0
      */
     function getEncoding($data)
+    {
         global $XML_RPC_defencoding;
-c22a703
+            Seth Mos
         if ($GLOBALS['XML_RPC_func_ereg']('<\?xml[^>]*[:space:]*encoding[:space:]*=[:space:]*[\'"]([^"\']*)[\'"]',
-            aa0d74da
+                       $data, $match))
+        {
             $match[1] = trim(strtoupper($match[1]));
             switch ($match[1]) {
                 case 'ISO-8859-1':
                 case 'UTF-8':
                 case 'US-ASCII':
                     return $match[1];
-c22a703
+                    break;
-            aa0d74da
+            Colin Smith
                 default:
                     return $XML_RPC_defencoding;
+            }
         } else {
             return $XML_RPC_defencoding;
+        }
+    }
     /**
      * @return object  a new XML_RPC_Response object
      */
     function parseResponseFile($fp)
+    {
         $ipd = '';
         while ($data = @fread($fp, 8192)) {
             $ipd .= $data;
+        }
         return $this->parseResponse($ipd);
+    }
     /**
      * @return object  a new XML_RPC_Response object
      */
     function parseResponse($data = '')
+    {
         global $XML_RPC_xh, $XML_RPC_err, $XML_RPC_str, $XML_RPC_defencoding;
         $encoding = $this->getEncoding($data);
         $parser_resource = xml_parser_create($encoding);
         $parser = (int) $parser_resource;
-b6983
+        $XML_RPC_xh = array();
-            aa0d74da
+        $XML_RPC_xh[$parser] = array();
         $XML_RPC_xh[$parser]['cm'] = 0;
         $XML_RPC_xh[$parser]['isf'] = 0;
         $XML_RPC_xh[$parser]['ac'] = '';
         $XML_RPC_xh[$parser]['qt'] = '';
-b6983
+        $XML_RPC_xh[$parser]['stack'] = array();
         $XML_RPC_xh[$parser]['valuestack'] = array();
-            aa0d74da
+            Colin Smith
         xml_parser_set_option($parser_resource, XML_OPTION_CASE_FOLDING, true);
         xml_set_element_handler($parser_resource, 'XML_RPC_se', 'XML_RPC_ee');
         xml_set_character_data_handler($parser_resource, 'XML_RPC_cd');
         $hdrfnd = 0;
         if ($this->debug) {
-b6983
+            print "\n<pre>---GOT---\n";
-            aa0d74da
+            print isset($_SERVER['SERVER_PROTOCOL']) ? htmlspecialchars($data) : $data;
-b6983
+            print "\n---END---</pre>\n";
-            aa0d74da
+            Colin Smith
-e5
+        // See if response is a 200 or a 100 then a 200, else raise error.
         // But only do this if we're using the HTTP protocol.
-c22a703
+        if ($GLOBALS['XML_RPC_func_ereg']('^HTTP', $data) &&
             !$GLOBALS['XML_RPC_func_ereg']('^HTTP/[0-9\.]+ 200 ', $data) &&
             !$GLOBALS['XML_RPC_func_ereg']('^HTTP/[0-9\.]+ 10[0-9]([A-Z ]+)?[\r\n]+HTTP/[0-9\.]+ 200', $data))
-e5
+            Bill Marquette
-            aa0d74da
+                $errstr = substr($data, 0, strpos($data, "\n") - 1);
-b6983
+                error_log('HTTP error, got response: ' . $errstr);
-            aa0d74da
+                $r = new XML_RPC_Response(0, $XML_RPC_err['http_error'],
                                           $XML_RPC_str['http_error'] . ' (' .
                                           $errstr . ')');
                 xml_parser_free($parser_resource);
                 return $r;
+        }
-b6983
+        // gotta get rid of headers here
-e5
+        if (!$hdrfnd && ($brpos = strpos($data,"\r\n\r\n"))) {
-            aa0d74da
+            $XML_RPC_xh[$parser]['ha'] = substr($data, 0, $brpos);
             $data = substr($data, $brpos + 4);
             $hdrfnd = 1;
+        }
         /*
          * be tolerant of junk after methodResponse
          * (e.g. javascript automatically inserted by free hosts)
          * thanks to Luca Mariano <luca.mariano@email.it>
          */
         $data = substr($data, 0, strpos($data, "</methodResponse>") + 17);
-c22a703
+        $this->response_payload = $data;
-            aa0d74da
+            Colin Smith
         if (!xml_parse($parser_resource, $data, sizeof($data))) {
             // thanks to Peter Kocks <peter.kocks@baygate.com>
-e5
+            if (xml_get_current_line_number($parser_resource) == 1) {
-            aa0d74da
+                $errstr = 'XML error at line 1, check URL';
             } else {
                 $errstr = sprintf('XML error: %s at line %d',
                                   xml_error_string(xml_get_error_code($parser_resource)),
                                   xml_get_current_line_number($parser_resource));
+            }
-b6983
+            error_log($errstr);
-            aa0d74da
+            $r = new XML_RPC_Response(0, $XML_RPC_err['invalid_return'],
                                       $XML_RPC_str['invalid_return']);
             xml_parser_free($parser_resource);
             return $r;
+        }
-b6983
+            Colin Smith
-            aa0d74da
+        xml_parser_free($parser_resource);
-b6983
+            Colin Smith
-            aa0d74da
+        if ($this->debug) {
-b6983
+            print "\n<pre>---PARSED---\n";
             var_dump($XML_RPC_xh[$parser]['value']);
             print "---END---</pre>\n";
-            aa0d74da
+            Colin Smith
-b6983
+            Colin Smith
         if ($XML_RPC_xh[$parser]['isf'] > 1) {
             $r = new XML_RPC_Response(0, $XML_RPC_err['invalid_return'],
                                       $XML_RPC_str['invalid_return'].' '.$XML_RPC_xh[$parser]['isf_reason']);
         } elseif (!is_object($XML_RPC_xh[$parser]['value'])) {
-            aa0d74da
+            // then something odd has happened
             // and it's time to generate a client side error
             // indicating something odd went on
             $r = new XML_RPC_Response(0, $XML_RPC_err['invalid_return'],
                                       $XML_RPC_str['invalid_return']);
         } else {
-b6983
+            $v = $XML_RPC_xh[$parser]['value'];
-            aa0d74da
+            if ($XML_RPC_xh[$parser]['isf']) {
                 $f = $v->structmem('faultCode');
                 $fs = $v->structmem('faultString');
                 $r = new XML_RPC_Response($v, $f->scalarval(),
                                           $fs->scalarval());
             } else {
                 $r = new XML_RPC_Response($v);
+            }
+        }
         $r->hdrs = split("\r?\n", $XML_RPC_xh[$parser]['ha'][1]);
         return $r;
+    }
+}
 /**
-e5
+ * The methods and properties that represent data in XML RPC format
-            aa0d74da
+            Colin Smith
  * @category   Web Services
  * @package    XML_RPC
  * @author     Edd Dumbill <edd@usefulinc.com>
  * @author     Stig Bakken <stig@php.net>
  * @author     Martin Jansen <mj@php.net>
-e5
+ * @author     Daniel Convissor <danielc@php.net>
-c22a703
+ * @copyright  1999-2001 Edd Dumbill, 2001-2006 The PHP Group
  * @version    Release: 1.5.1
-            aa0d74da
+ * @link       http://pear.php.net/package/XML_RPC
  */
 class XML_RPC_Value extends XML_RPC_Base
+{
     var $me = array();
     var $mytype = 0;
     /**
      * @return void
      */
     function XML_RPC_Value($val = -1, $type = '')
+    {
         $this->me = array();
         $this->mytype = 0;
         if ($val != -1 || $type != '') {
             if ($type == '') {
                 $type = 'string';
+            }
-c22a703
+            if (!array_key_exists($type, $GLOBALS['XML_RPC_Types'])) {
-            aa0d74da
+                // XXX
                 // need some way to report this error
-c22a703
+            } elseif ($GLOBALS['XML_RPC_Types'][$type] == 1) {
-            aa0d74da
+                $this->addScalar($val, $type);
-c22a703
+            } elseif ($GLOBALS['XML_RPC_Types'][$type] == 2) {
-            aa0d74da
+                $this->addArray($val);
-c22a703
+            } elseif ($GLOBALS['XML_RPC_Types'][$type] == 3) {
-            aa0d74da
+                $this->addStruct($val);
+            }
+        }
+    }
     /**
      * @return int  returns 1 if successful or 0 if there are problems
      */
     function addScalar($val, $type = 'string')
+    {
         if ($this->mytype == 1) {
             $this->raiseError('Scalar can have only one value',
                               XML_RPC_ERROR_INVALID_TYPE);
             return 0;
+        }
-c22a703
+        $typeof = $GLOBALS['XML_RPC_Types'][$type];
-            aa0d74da
+        if ($typeof != 1) {
             $this->raiseError("Not a scalar type (${typeof})",
                               XML_RPC_ERROR_INVALID_TYPE);
             return 0;
+        }
-c22a703
+        if ($type == $GLOBALS['XML_RPC_Boolean']) {
-            aa0d74da
+            if (strcasecmp($val, 'true') == 0
                 || $val == 1
                 || ($val == true && strcasecmp($val, 'false')))
+            {
                 $val = 1;
             } else {
                 $val = 0;
+            }
+        }
         if ($this->mytype == 2) {
             // we're adding to an array here
             $ar = $this->me['array'];
             $ar[] = new XML_RPC_Value($val, $type);
             $this->me['array'] = $ar;
         } else {
             // a scalar, so set the value and remember we're scalar
             $this->me[$type] = $val;
             $this->mytype = $typeof;
+        }
         return 1;
+    }
     /**
      * @return int  returns 1 if successful or 0 if there are problems
      */
     function addArray($vals)
+    {
         if ($this->mytype != 0) {
             $this->raiseError(
                     'Already initialized as a [' . $this->kindOf() . ']',
                     XML_RPC_ERROR_ALREADY_INITIALIZED);
             return 0;
+        }
-c22a703
+        $this->mytype = $GLOBALS['XML_RPC_Types']['array'];
-            aa0d74da
+        $this->me['array'] = $vals;
         return 1;
+    }
     /**
      * @return int  returns 1 if successful or 0 if there are problems
      */
     function addStruct($vals)
+    {
         if ($this->mytype != 0) {
             $this->raiseError(
                     'Already initialized as a [' . $this->kindOf() . ']',
                     XML_RPC_ERROR_ALREADY_INITIALIZED);
             return 0;
+        }
-c22a703
+        $this->mytype = $GLOBALS['XML_RPC_Types']['struct'];
-            aa0d74da
+        $this->me['struct'] = $vals;
         return 1;
+    }
     /**
      * @return void
      */
     function dump($ar)
+    {
         reset($ar);
-e5
+        foreach ($ar as $key => $val) {
             echo "$key => $val<br />";
-            aa0d74da
+            if ($key == 'array') {
-e5
+                foreach ($val as $key2 => $val2) {
                     echo "-- $key2 => $val2<br />";
-            aa0d74da
+            Colin Smith
+            }
+        }
+    }
     /**
      * @return string  the data type of the current value
      */
     function kindOf()
+    {
         switch ($this->mytype) {
         case 3:
             return 'struct';
         case 2:
             return 'array';
         case 1:
             return 'scalar';
         default:
             return 'undef';
+        }
+    }
     /**
      * @return string  the data in XML format
      */
     function serializedata($typ, $val)
+    {
         $rs = '';
-c22a703
+        if (!array_key_exists($typ, $GLOBALS['XML_RPC_Types'])) {
-            aa0d74da
+            // XXX
             // need some way to report this error
             return;
+        }
-c22a703
+        switch ($GLOBALS['XML_RPC_Types'][$typ]) {
-            aa0d74da
+        case 3:
             // struct
             $rs .= "<struct>\n";
             reset($val);
-e5
+            foreach ($val as $key2 => $val2) {
-            aa0d74da
+                $rs .= "<member><name>${key2}</name>\n";
                 $rs .= $this->serializeval($val2);
                 $rs .= "</member>\n";
+            }
             $rs .= '</struct>';
             break;
         case 2:
             // array
             $rs .= "<array>\n<data>\n";
             for ($i = 0; $i < sizeof($val); $i++) {
                 $rs .= $this->serializeval($val[$i]);
+            }
             $rs .= "</data>\n</array>";
             break;
         case 1:
             switch ($typ) {
-c22a703
+            case $GLOBALS['XML_RPC_Base64']:
-            aa0d74da
+                $rs .= "<${typ}>" . base64_encode($val) . "</${typ}>";
                 break;
-c22a703
+            case $GLOBALS['XML_RPC_Boolean']:
-            aa0d74da
+                $rs .= "<${typ}>" . ($val ? '1' : '0') . "</${typ}>";
                 break;
-c22a703
+            case $GLOBALS['XML_RPC_String']:
-            aa0d74da
+                $rs .= "<${typ}>" . htmlspecialchars($val). "</${typ}>";
                 break;
             default:
                 $rs .= "<${typ}>${val}</${typ}>";
+            }
+        }
         return $rs;
+    }
     /**
      * @return string  the data in XML format
      */
     function serialize()
+    {
         return $this->serializeval($this);
+    }
     /**
      * @return string  the data in XML format
      */
     function serializeval($o)
+    {
-b6983
+        if (!is_object($o) || empty($o->me) || !is_array($o->me)) {
             return '';
+        }
-            aa0d74da
+        $ar = $o->me;
         reset($ar);
         list($typ, $val) = each($ar);
-b6983
+        return '<value>' .  $this->serializedata($typ, $val) .  "</value>\n";
-            aa0d74da
+            Colin Smith
     /**
      * @return mixed  the contents of the element requested
      */
     function structmem($m)
+    {
         return $this->me['struct'][$m];
+    }
     /**
      * @return void
      */
     function structreset()
+    {
         reset($this->me['struct']);
+    }
     /**
      * @return  the key/value pair of the struct's current element
      */
     function structeach()
+    {
         return each($this->me['struct']);
+    }
     /**
      * @return mixed  the current value
      */
-e5
+    function getval()
+    {
-            aa0d74da
+        // UNSTABLE
         reset($this->me);
-e5
+        $b = current($this->me);
-            aa0d74da
+            Colin Smith
         // contributed by I Sofer, 2001-03-24
         // add support for nested arrays to scalarval
         // i've created a new method here, so as to
         // preserve back compatibility
         if (is_array($b)) {
             foreach ($b as $id => $cont) {
                 $b[$id] = $cont->scalarval();
+            }
+        }
         // add support for structures directly encoding php objects
         if (is_object($b)) {
             $t = get_object_vars($b);
             foreach ($t as $id => $cont) {
                 $t[$id] = $cont->scalarval();
+            }
             foreach ($t as $id => $cont) {
-b6983
+                $b->$id = $cont;
-            aa0d74da
+            Colin Smith
+        }
         // end contrib
         return $b;
+    }
     /**
-c22a703
+     * @return mixed  the current element's scalar value.  If the value is
      *                 not scalar, FALSE is returned.
-            aa0d74da
+     */
     function scalarval()
+    {
         reset($this->me);
-c22a703
+        $v = current($this->me);
         if (!is_scalar($v)) {
             $v = false;
+        }
         return $v;
-            aa0d74da
+            Colin Smith
     /**
      * @return string
      */
     function scalartyp()
+    {
         reset($this->me);
-e5
+        $a = key($this->me);
-c22a703
+        if ($a == $GLOBALS['XML_RPC_I4']) {
             $a = $GLOBALS['XML_RPC_Int'];
-            aa0d74da
+            Colin Smith
         return $a;
+    }
     /**
      * @return mixed  the struct's current element
      */
     function arraymem($m)
+    {
         return $this->me['array'][$m];
+    }
     /**
      * @return int  the number of elements in the array
      */
     function arraysize()
+    {
         reset($this->me);
         list($a, $b) = each($this->me);
         return sizeof($b);
+    }
-e5
+            Bill Marquette
     /**
      * Determines if the item submitted is an XML_RPC_Value object
+     *
      * @param mixed $val  the variable to be evaluated
+     *
      * @return bool  TRUE if the item is an XML_RPC_Value object
+     *
      * @static
      * @since Method available since Release 1.3.0
      */
     function isValue($val)
+    {
         return (strtolower(get_class($val)) == 'xml_rpc_value');
+    }
-            aa0d74da
+            Colin Smith
 /**
  * Return an ISO8601 encoded string
+ *
  * While timezones ought to be supported, the XML-RPC spec says:
+ *
  * "Don't assume a timezone. It should be specified by the server in its
  * documentation what assumptions it makes about timezones."
+ *
  * This routine always assumes localtime unless $utc is set to 1, in which
  * case UTC is assumed and an adjustment for locale is made when encoding.
+ *
  * @return string  the formatted date
  */
-e5
+function XML_RPC_iso8601_encode($timet, $utc = 0)
+{
-            aa0d74da
+    if (!$utc) {
         $t = strftime('%Y%m%dT%H:%M:%S', $timet);
     } else {
         if (function_exists('gmstrftime')) {
             // gmstrftime doesn't exist in some versions
             // of PHP
             $t = gmstrftime('%Y%m%dT%H:%M:%S', $timet);
         } else {
             $t = strftime('%Y%m%dT%H:%M:%S', $timet - date('Z'));
+        }
+    }
     return $t;
+}
 /**
  * Convert a datetime string into a Unix timestamp
+ *
  * While timezones ought to be supported, the XML-RPC spec says:
+ *
  * "Don't assume a timezone. It should be specified by the server in its
  * documentation what assumptions it makes about timezones."
+ *
  * This routine always assumes localtime unless $utc is set to 1, in which
  * case UTC is assumed and an adjustment for locale is made when encoding.
+ *
  * @return int  the unix timestamp of the date submitted
  */
-e5
+function XML_RPC_iso8601_decode($idate, $utc = 0)
+{
-            aa0d74da
+    $t = 0;
-c22a703
+    if ($GLOBALS['XML_RPC_func_ereg']('([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})', $idate, $regs)) {
-            aa0d74da
+        if ($utc) {
             $t = gmmktime($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
         } else {
             $t = mktime($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
+        }
+    }
     return $t;
+}
 /**
-e5
+ * Converts an XML_RPC_Value object into native PHP types
-            aa0d74da
+            Colin Smith
-e5
+ * @param object $XML_RPC_val  the XML_RPC_Value object to decode
-            aa0d74da
+            Colin Smith
-e5
+ * @return mixed  the PHP values
-            aa0d74da
+ */
 function XML_RPC_decode($XML_RPC_val)
+{
     $kind = $XML_RPC_val->kindOf();
     if ($kind == 'scalar') {
         return $XML_RPC_val->scalarval();
     } elseif ($kind == 'array') {
         $size = $XML_RPC_val->arraysize();
         $arr = array();
         for ($i = 0; $i < $size; $i++) {
             $arr[] = XML_RPC_decode($XML_RPC_val->arraymem($i));
+        }
         return $arr;
     } elseif ($kind == 'struct') {
         $XML_RPC_val->structreset();
         $arr = array();
         while (list($key, $value) = $XML_RPC_val->structeach()) {
             $arr[$key] = XML_RPC_decode($value);
+        }
         return $arr;
+    }
+}
 /**
-e5
+ * Converts native PHP types into an XML_RPC_Value object
-            aa0d74da
+            Colin Smith
-e5
+ * @param mixed $php_val  the PHP value or variable you want encoded
-            aa0d74da
+            Colin Smith
-e5
+ * @return object  the XML_RPC_Value object
-            aa0d74da
+ */
-e5
+function XML_RPC_encode($php_val)
+{
-            aa0d74da
+    $type = gettype($php_val);
     $XML_RPC_val = new XML_RPC_Value;
     switch ($type) {
     case 'array':
         if (empty($php_val)) {
             $XML_RPC_val->addArray($php_val);
             break;
+        }
         $tmp = array_diff(array_keys($php_val), range(0, count($php_val)-1));
         if (empty($tmp)) {
            $arr = array();
            foreach ($php_val as $k => $v) {
                $arr[$k] = XML_RPC_encode($v);
+           }
            $XML_RPC_val->addArray($arr);
            break;
+        }
         // fall though if it's not an enumerated array
     case 'object':
         $arr = array();
         foreach ($php_val as $k => $v) {
             $arr[$k] = XML_RPC_encode($v);
+        }
         $XML_RPC_val->addStruct($arr);
         break;
     case 'integer':
-c22a703
+        $XML_RPC_val->addScalar($php_val, $GLOBALS['XML_RPC_Int']);
-            aa0d74da
+        break;
     case 'double':
-c22a703
+        $XML_RPC_val->addScalar($php_val, $GLOBALS['XML_RPC_Double']);
-            aa0d74da
+        break;
     case 'string':
     case 'NULL':
-c22a703
+        if ($GLOBALS['XML_RPC_func_ereg']('^[0-9]{8}\T{1}[0-9]{2}\:[0-9]{2}\:[0-9]{2}$', $php_val)) {
             $XML_RPC_val->addScalar($php_val, $GLOBALS['XML_RPC_DateTime']);
         } elseif ($GLOBALS['XML_RPC_auto_base64']
                   && $GLOBALS['XML_RPC_func_ereg']("[^ -~\t\r\n]", $php_val))
+        {
             // Characters other than alpha-numeric, punctuation, SP, TAB,
             // LF and CR break the XML parser, encode value via Base 64.
             $XML_RPC_val->addScalar($php_val, $GLOBALS['XML_RPC_Base64']);
-            b755666f
+        } else {
-c22a703
+            $XML_RPC_val->addScalar($php_val, $GLOBALS['XML_RPC_String']);
-            b755666f
+            Scott Ullrich
-            aa0d74da
+        break;
     case 'boolean':
         // Add support for encoding/decoding of booleans, since they
         // are supported in PHP
         // by <G_Giunta_2001-02-29>
-c22a703
+        $XML_RPC_val->addScalar($php_val, $GLOBALS['XML_RPC_Boolean']);
-            aa0d74da
+        break;
     case 'unknown type':
     default:
         $XML_RPC_val = false;
+    }
     return $XML_RPC_val;
+}
 /*
  * Local variables:
  * tab-width: 4
  * c-basic-offset: 4
  * c-hanging-comment-ender-p: nil
  * End:
  */
-            26732357
+?>

Project

General

Profile

pfSense