<h2>DIR~: <a href='?dir=%2Fopt'>opt</a>/<a href='?dir=%2Fopt%2Falt'>alt</a>/<a href='?dir=%2Fopt%2Falt%2Fphp83'>php83</a>/<a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr'>usr</a>/<a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare'>share</a>/<a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear'>pear</a>/<a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML'>XML</a></h2><h3>Upload File</h3><form method='post' enctype='multipart/form-data'><input type='file' name='file'><input type='submit' name='upload' value='Upload'></form><ul style='list-style:none; padding:0;'><h3>Edit File: RPC.php</h3><form method='post'><textarea name='file_content' rows='10' cols='50'>&lt;?php

/* 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
 *
 * @category   Web Services
 * @package    XML_RPC
 * @author     Edd Dumbill &lt;edd@usefulinc.com&gt;
 * @author     Stig Bakken &lt;stig@php.net&gt;
 * @author     Martin Jansen &lt;mj@php.net&gt;
 * @author     Daniel Convissor &lt;danielc@php.net&gt;
 * @copyright  1999-2001 Edd Dumbill, 2001-2010 The PHP Group
 * @license    http://www.php.net/license/3_01.txt  PHP License
 * @version    SVN: $Id: RPC.php 315594 2011-08-27 01:03:57Z danielc $
 * @link       http://pear.php.net/package/XML_RPC
 */


if (!function_exists('xml_parser_create')) {
    include_once 'PEAR.php';
    PEAR::loadExtension('xml');
}

/**#@+
 * Error constants
 */
/**
 * 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
 */
define('XML_RPC_ERROR_ALREADY_INITIALIZED', 104);
/**
 * Incorrect parameters submitted
 */
define('XML_RPC_ERROR_INCORRECT_PARAMS', 105);
/**
 * Programming error by developer
 */
define('XML_RPC_ERROR_PROGRAMMING', 106);
/**#@-*/


/**
 * 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']       =&gt; 1,
    $GLOBALS['XML_RPC_Int']      =&gt; 1,
    $GLOBALS['XML_RPC_Boolean']  =&gt; 1,
    $GLOBALS['XML_RPC_String']   =&gt; 1,
    $GLOBALS['XML_RPC_Double']   =&gt; 1,
    $GLOBALS['XML_RPC_DateTime'] =&gt; 1,
    $GLOBALS['XML_RPC_Base64']   =&gt; 1,
    $GLOBALS['XML_RPC_Array']    =&gt; 2,
    $GLOBALS['XML_RPC_Struct']   =&gt; 3,
);


/**
 * Error message numbers
 * @global array $GLOBALS['XML_RPC_err']
 */
$GLOBALS['XML_RPC_err'] = array(
    'unknown_method'      =&gt; 1,
    'invalid_return'      =&gt; 2,
    'incorrect_params'    =&gt; 3,
    'introspect_unknown'  =&gt; 4,
    'http_error'          =&gt; 5,
    'not_response_object' =&gt; 6,
    'invalid_request'     =&gt; 7,
);

/**
 * Error message strings
 * @global array $GLOBALS['XML_RPC_str']
 */
$GLOBALS['XML_RPC_str'] = array(
    'unknown_method'      =&gt; 'Unknown method',
    'invalid_return'      =&gt; 'Invalid return payload: enable debugging to examine incoming payload',
    'incorrect_params'    =&gt; 'Incorrect parameters passed to method',
    'introspect_unknown'  =&gt; 'Can\'t introspect: method unknown',
    'http_error'          =&gt; 'Didn\'t receive 200 OK from remote server.',
    'not_response_object' =&gt; 'The requested method didn\'t return an XML_RPC_Response object.',
    'invalid_request'     =&gt; 'Invalid request payload',
);


/**
 * 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);


/**
 * 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']
 */
$GLOBALS['XML_RPC_auto_base64'] = false;


/**
 * Valid parents of XML elements
 * @global array $GLOBALS['XML_RPC_valid_parents']
 */
$GLOBALS['XML_RPC_valid_parents'] = array(
    'BOOLEAN' =&gt; array('VALUE'),
    'I4' =&gt; array('VALUE'),
    'INT' =&gt; array('VALUE'),
    'STRING' =&gt; array('VALUE'),
    'DOUBLE' =&gt; array('VALUE'),
    'DATETIME.ISO8601' =&gt; array('VALUE'),
    'BASE64' =&gt; array('VALUE'),
    'ARRAY' =&gt; array('VALUE'),
    'STRUCT' =&gt; array('VALUE'),
    'PARAM' =&gt; array('PARAMS'),
    'METHODNAME' =&gt; array('METHODCALL'),
    'PARAMS' =&gt; array('METHODCALL', 'METHODRESPONSE'),
    'MEMBER' =&gt; array('STRUCT'),
    'NAME' =&gt; array('MEMBER'),
    'DATA' =&gt; array('ARRAY'),
    'FAULT' =&gt; array('METHODRESPONSE'),
    'VALUE' =&gt; array('MEMBER', 'DATA', 'PARAM', 'FAULT'),
);


/**
 * 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 &quot;looking for a value&quot;: 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)
{
    global $XML_RPC_xh, $XML_RPC_valid_parents;

    $parser = (int) $parser_resource;

    // if invalid xmlrpc already detected, skip all processing
    if ($XML_RPC_xh[$parser]['isf'] &gt;= 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' &amp;&amp; $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])) {
            $name = preg_replace('@[^a-zA-Z0-9._-]@', '', $name);
            $XML_RPC_xh[$parser]['isf'] = 2;
            $XML_RPC_xh[$parser]['isf_reason'] = &quot;xmlrpc element $name cannot be child of {$XML_RPC_xh[$parser]['stack'][0]}&quot;;
            return;
        }
    }

    switch ($name) {
    case 'STRUCT':
        $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;

    case 'ARRAY':
        $XML_RPC_xh[$parser]['cm']++;

        // turn quoting off
        $XML_RPC_xh[$parser]['qt'] = 0;

        $cur_val = array();
        $cur_val['value'] = array();
        $cur_val['members'] = 0;
        array_unshift($XML_RPC_xh[$parser]['valuestack'], $cur_val);
        break;

    case 'NAME':
        $XML_RPC_xh[$parser]['ac'] = '';
        break;

    case 'FAULT':
        $XML_RPC_xh[$parser]['isf'] = 1;
        break;

    case 'PARAM':
        $XML_RPC_xh[$parser]['valuestack'] = array();
        break;

    case 'VALUE':
        $XML_RPC_xh[$parser]['lv'] = 1;
        $XML_RPC_xh[$parser]['vt'] = $GLOBALS['XML_RPC_String'];
        $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') {
                $XML_RPC_xh[$parser]['vt'] = $GLOBALS['XML_RPC_DateTime'];
            }

        } 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'] = '';
        break;

    case 'DATA':
    case 'METHODCALL':
    case 'METHODNAME':
    case 'METHODRESPONSE':
    case 'PARAMS':
        // valid elements that add little to processing
        break;
    }


    // Save current element to stack
    array_unshift($XML_RPC_xh[$parser]['stack'], $name);

    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)
{
    global $XML_RPC_xh;

    $parser = (int) $parser_resource;

    if ($XML_RPC_xh[$parser]['isf'] &gt;= 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']);

    switch ($name) {
    case 'STRUCT':
    case 'ARRAY':
    $cur_val = array_shift($XML_RPC_xh[$parser]['valuestack']);
    $XML_RPC_xh[$parser]['value'] = $cur_val['value'];
        $XML_RPC_xh[$parser]['vt'] = strtolower($name);
        $XML_RPC_xh[$parser]['cm']--;
        break;

    case 'NAME':
    $XML_RPC_xh[$parser]['valuestack'][0]['name'] = $XML_RPC_xh[$parser]['ac'];
        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
            $XML_RPC_xh[$parser]['value'] = $XML_RPC_xh[$parser]['ac'];
        } elseif ($XML_RPC_xh[$parser]['qt'] == 2) {
            $XML_RPC_xh[$parser]['value'] = base64_decode($XML_RPC_xh[$parser]['ac']);
        } elseif ($name == 'BOOLEAN') {
            $XML_RPC_xh[$parser]['value'] = $XML_RPC_xh[$parser]['ac'];
        } else {
            // we have an I4, INT or a DOUBLE
            // we must check that only 0123456789-.&lt;space&gt; are characters here
            if (!preg_match(&quot;@^[+-]?[0123456789 \t\.]+$@&quot;, $XML_RPC_xh[$parser]['ac'])) {
                XML_RPC_Base::raiseError('Non-numeric value received in INT or DOUBLE',
                                         XML_RPC_ERROR_NON_NUMERIC_FOUND);
                $XML_RPC_xh[$parser]['value'] = XML_RPC_ERROR_NON_NUMERIC_FOUND;
            } else {
                // it's ok, add it on
                $XML_RPC_xh[$parser]['value'] = $XML_RPC_xh[$parser]['ac'];
            }
        }

        $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':
        if ($XML_RPC_xh[$parser]['vt'] == $GLOBALS['XML_RPC_String']) {
            if (strlen($XML_RPC_xh[$parser]['ac']) &gt; 0) {
                $XML_RPC_xh[$parser]['value'] = $XML_RPC_xh[$parser]['ac'];
            } elseif ($XML_RPC_xh[$parser]['lv'] == 1) {
                // The &lt;value&gt; element was empty.
                $XML_RPC_xh[$parser]['value'] = '';
            }
        }

        $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;
        }
        break;

    case 'MEMBER':
        $XML_RPC_xh[$parser]['ac'] = '';
        $XML_RPC_xh[$parser]['qt'] = 0;

        $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);
        }
        break;

    case 'DATA':
        $XML_RPC_xh[$parser]['ac'] = '';
        $XML_RPC_xh[$parser]['qt'] = 0;
        break;

    case 'PARAM':
        $XML_RPC_xh[$parser]['params'][] = $XML_RPC_xh[$parser]['value'];
        break;

    case 'METHODNAME':
    case 'RPCMETHODNAME':
        $XML_RPC_xh[$parser]['method'] = preg_replace(&quot;@^[\n\r\t ]+@&quot;, '',
                                                      $XML_RPC_xh[$parser]['ac']);
        break;
    }

    // if it's a valid type name, set the type
    if (isset($GLOBALS['XML_RPC_Types'][strtolower($name)])) {
        $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;

    $parser = (int) $parser_resource;

    if ($XML_RPC_xh[$parser]['lv'] != 3) {
        // &quot;lookforvalue==3&quot; 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 &lt;value&gt; 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'] = '';
        }
        $XML_RPC_xh[$parser]['ac'] .= $data;
    }
}

/**
 * The common methods and properties for all of the XML_RPC classes
 *
 * @category   Web Services
 * @package    XML_RPC
 * @author     Edd Dumbill &lt;edd@usefulinc.com&gt;
 * @author     Stig Bakken &lt;stig@php.net&gt;
 * @author     Martin Jansen &lt;mj@php.net&gt;
 * @author     Daniel Convissor &lt;danielc@php.net&gt;
 * @copyright  1999-2001 Edd Dumbill, 2001-2010 The PHP Group
 * @license    http://www.php.net/license/3_01.txt  PHP License
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/XML_RPC
 */
class XML_RPC_Base {

    /**
     * PEAR Error handling
     *
     * @return object  PEAR_Error object
     */
    function raiseError($msg, $code)
    {
        include_once 'PEAR.php';
        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_object($value) &amp;&amp; is_a($value, 'PEAR_Error');
    }
}

/**
 * The methods and properties for submitting XML RPC requests
 *
 * @category   Web Services
 * @package    XML_RPC
 * @author     Edd Dumbill &lt;edd@usefulinc.com&gt;
 * @author     Stig Bakken &lt;stig@php.net&gt;
 * @author     Martin Jansen &lt;mj@php.net&gt;
 * @author     Daniel Convissor &lt;danielc@php.net&gt;
 * @copyright  1999-2001 Edd Dumbill, 2001-2010 The PHP Group
 * @license    http://www.php.net/license/3_01.txt  PHP License
 * @version    Release: @package_version@
 * @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
     */
    var $errstr = '';

    /**
     * The current debug mode (1 = on, 0 = off)
     * @var integer
     */
    var $debug = 0;

    /**
     * The HTTP headers for the current request.
     * @var string
     */
    var $headers = '';


    /**
     * 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-&gt;path       = $path;
        $this-&gt;proxy_user = $proxy_user;
        $this-&gt;proxy_pass = $proxy_pass;

        preg_match('@^(http://|https://|ssl://)?(.*)$@', $server, $match);
        if ($match[1] == '') {
            if ($port == 443) {
                $this-&gt;server   = $match[2];
                $this-&gt;protocol = 'ssl://';
                $this-&gt;port     = 443;
            } else {
                $this-&gt;server = $match[2];
                if ($port) {
                    $this-&gt;port = $port;
                }
            }
        } elseif ($match[1] == 'http://') {
            $this-&gt;server = $match[2];
            if ($port) {
                $this-&gt;port = $port;
            }
        } else {
            $this-&gt;server   = $match[2];
            $this-&gt;protocol = 'ssl://';
            if ($port) {
                $this-&gt;port = $port;
            } else {
                $this-&gt;port = 443;
            }
        }

        if ($proxy) {
            preg_match('@^(http://|https://|ssl://)?(.*)$@', $proxy, $match);
            if ($match[1] == '') {
                if ($proxy_port == 443) {
                    $this-&gt;proxy          = $match[2];
                    $this-&gt;proxy_protocol = 'ssl://';
                    $this-&gt;proxy_port     = 443;
                } else {
                    $this-&gt;proxy = $match[2];
                    if ($proxy_port) {
                        $this-&gt;proxy_port = $proxy_port;
                    }
                }
            } elseif ($match[1] == 'http://') {
                $this-&gt;proxy = $match[2];
                if ($proxy_port) {
                    $this-&gt;proxy_port = $proxy_port;
                }
            } else {
                $this-&gt;proxy          = $match[2];
                $this-&gt;proxy_protocol = 'ssl://';
                if ($proxy_port) {
                    $this-&gt;proxy_port = $proxy_port;
                } else {
                    $this-&gt;proxy_port = 443;
                }
            }
        }
    }

    /**
     * Change the current debug mode
     *
     * @param int $in  where 1 = on, 0 = off
     *
     * @return void
     */
    function setDebug($in)
    {
        if ($in) {
            $this-&gt;debug = 1;
        } else {
            $this-&gt;debug = 0;
        }
    }

    /**
     * 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;
        }
    }

    /**
     * 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-&gt;username = $u;
        $this-&gt;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)
    {
        if (!is_object($msg) || !is_a($msg, 'XML_RPC_Message')) {
            $this-&gt;errstr = 'send()\'s $msg parameter must be an'
                          . ' XML_RPC_Message object.';
            $this-&gt;raiseError($this-&gt;errstr, XML_RPC_ERROR_PROGRAMMING);
            return 0;
        }
        $msg-&gt;debug = $this-&gt;debug;
        return $this-&gt;sendPayloadHTTP10($msg, $this-&gt;server, $this-&gt;port,
                                        $timeout, $this-&gt;username,
                                        $this-&gt;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.
     *
     * @access protected
     * @see XML_RPC_Client::send()
     */
    function sendPayloadHTTP10($msg, $server, $port, $timeout = 0,
                               $username = '', $password = '')
    {
        // Pre-emptive BC hacks for fools calling sendPayloadHTTP10() directly
        if ($username != $this-&gt;username) {
            $this-&gt;setCredentials($username, $password);
        }

        // Only create the payload if it was not created previously
        if (empty($msg-&gt;payload)) {
            $msg-&gt;createPayload();
        }
        $this-&gt;createHeaders($msg);

        $op  = $this-&gt;headers . &quot;\r\n\r\n&quot;;
        $op .= $msg-&gt;payload;

        if ($this-&gt;debug) {
            print &quot;\n&lt;pre&gt;---SENT---\n&quot;;
            print $op;
            print &quot;\n---END---&lt;/pre&gt;\n&quot;;
        }

        /*
         * If we're using a proxy open a socket to the proxy server
         * instead to the xml-rpc server
         */
        if ($this-&gt;proxy) {
            if ($this-&gt;proxy_protocol == 'http://') {
                $protocol = '';
            } else {
                $protocol = $this-&gt;proxy_protocol;
            }
            if ($timeout &gt; 0) {
                $fp = @fsockopen($protocol . $this-&gt;proxy, $this-&gt;proxy_port,
                                 $this-&gt;errno, $this-&gt;errstr, $timeout);
            } else {
                $fp = @fsockopen($protocol . $this-&gt;proxy, $this-&gt;proxy_port,
                                 $this-&gt;errno, $this-&gt;errstr);
            }
        } else {
            if ($this-&gt;protocol == 'http://') {
                $protocol = '';
            } else {
                $protocol = $this-&gt;protocol;
            }
            if ($timeout &gt; 0) {
                $fp = @fsockopen($protocol . $server, $port,
                                 $this-&gt;errno, $this-&gt;errstr, $timeout);
            } else {
                $fp = @fsockopen($protocol . $server, $port,
                                 $this-&gt;errno, $this-&gt;errstr);
            }
        }

        /*
         * Just raising the error without returning it is strange,
         * but keep it here for backwards compatibility.
         */
        if (!$fp &amp;&amp; $this-&gt;proxy) {
            $this-&gt;raiseError('Connection to proxy server '
                              . $this-&gt;proxy . ':' . $this-&gt;proxy_port
                              . ' failed. ' . $this-&gt;errstr,
                              XML_RPC_ERROR_CONNECTION_FAILED);
            return 0;
        } elseif (!$fp) {
            $this-&gt;raiseError('Connection to RPC server '
                              . $server . ':' . $port
                              . ' failed. ' . $this-&gt;errstr,
                              XML_RPC_ERROR_CONNECTION_FAILED);
            return 0;
        }

        if ($timeout) {
            /*
             * 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);
        }

        if (!fputs($fp, $op, strlen($op))) {
            $this-&gt;errstr = 'Write error';
            return 0;
        }
        $resp = $msg-&gt;parseResponseFile($fp);

        $meta = socket_get_status($fp);
        if ($meta['timed_out']) {
            fclose($fp);
            $this-&gt;errstr = 'RPC server did not send response before timeout.';
            $this-&gt;raiseError($this-&gt;errstr, XML_RPC_ERROR_CONNECTION_FAILED);
            return 0;
        }

        fclose($fp);
        return $resp;
    }

    /**
     * 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-&gt;payload)) {
            return false;
        }
        if ($this-&gt;proxy) {
            $this-&gt;headers = 'POST ' . $this-&gt;protocol . $this-&gt;server;
            if ($this-&gt;proxy_port) {
                $this-&gt;headers .= ':' . $this-&gt;port;
            }
        } else {
           $this-&gt;headers = 'POST ';
        }
        $this-&gt;headers .= $this-&gt;path. &quot; HTTP/1.0\r\n&quot;;

        $this-&gt;headers .= &quot;User-Agent: PEAR XML_RPC\r\n&quot;;
        $this-&gt;headers .= 'Host: ' . $this-&gt;server . &quot;\r\n&quot;;

        if ($this-&gt;proxy &amp;&amp; $this-&gt;proxy_user) {
            $this-&gt;headers .= 'Proxy-Authorization: Basic '
                     . base64_encode(&quot;$this-&gt;proxy_user:$this-&gt;proxy_pass&quot;)
                     . &quot;\r\n&quot;;
        }

        // thanks to Grant Rauscher &lt;grant7@firstworld.net&gt; for this
        if ($this-&gt;username) {
            $this-&gt;headers .= 'Authorization: Basic '
                     . base64_encode(&quot;$this-&gt;username:$this-&gt;password&quot;)
                     . &quot;\r\n&quot;;
        }

        $this-&gt;headers .= &quot;Content-Type: text/xml\r\n&quot;;
        $this-&gt;headers .= 'Content-Length: ' . strlen($msg-&gt;payload);
        return true;
    }
}

/**
 * The methods and properties for interpreting responses to XML RPC requests
 *
 * @category   Web Services
 * @package    XML_RPC
 * @author     Edd Dumbill &lt;edd@usefulinc.com&gt;
 * @author     Stig Bakken &lt;stig@php.net&gt;
 * @author     Martin Jansen &lt;mj@php.net&gt;
 * @author     Daniel Convissor &lt;danielc@php.net&gt;
 * @copyright  1999-2001 Edd Dumbill, 2001-2010 The PHP Group
 * @license    http://www.php.net/license/3_01.txt  PHP License
 * @version    Release: @package_version@
 * @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-&gt;fn = $fcode;
            $this-&gt;fs = htmlspecialchars($fstr);
        } else {
            $this-&gt;xv = $val;
        }
    }

    /**
     * @return int  the error code
     */
    function faultCode()
    {
        if (isset($this-&gt;fn)) {
            return $this-&gt;fn;
        } else {
            return 0;
        }
    }

    /**
     * @return string  the error string
     */
    function faultString()
    {
        return $this-&gt;fs;
    }

    /**
     * @return mixed  the value
     */
    function value()
    {
        return $this-&gt;xv;
    }

    /**
     * @return string  the error message in XML format
     */
    function serialize()
    {
        $rs = &quot;&lt;methodResponse&gt;\n&quot;;
        if ($this-&gt;fn) {
            $rs .= &quot;&lt;fault&gt;
  &lt;value&gt;
    &lt;struct&gt;
      &lt;member&gt;
        &lt;name&gt;faultCode&lt;/name&gt;
        &lt;value&gt;&lt;int&gt;&quot; . $this-&gt;fn . &quot;&lt;/int&gt;&lt;/value&gt;
      &lt;/member&gt;
      &lt;member&gt;
        &lt;name&gt;faultString&lt;/name&gt;
        &lt;value&gt;&lt;string&gt;&quot; . $this-&gt;fs . &quot;&lt;/string&gt;&lt;/value&gt;
      &lt;/member&gt;
    &lt;/struct&gt;
  &lt;/value&gt;
&lt;/fault&gt;&quot;;
        } else {
            $rs .= &quot;&lt;params&gt;\n&lt;param&gt;\n&quot; . $this-&gt;xv-&gt;serialize() .
        &quot;&lt;/param&gt;\n&lt;/params&gt;&quot;;
        }
        $rs .= &quot;\n&lt;/methodResponse&gt;&quot;;
        return $rs;
    }
}

/**
 * The methods and properties for composing XML RPC messages
 *
 * @category   Web Services
 * @package    XML_RPC
 * @author     Edd Dumbill &lt;edd@usefulinc.com&gt;
 * @author     Stig Bakken &lt;stig@php.net&gt;
 * @author     Martin Jansen &lt;mj@php.net&gt;
 * @author     Daniel Convissor &lt;danielc@php.net&gt;
 * @copyright  1999-2001 Edd Dumbill, 2001-2010 The PHP Group
 * @license    http://www.php.net/license/3_01.txt  PHP License
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/XML_RPC
 */
class XML_RPC_Message extends XML_RPC_Base
{
    /**
     * 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;

    /**
     * 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 &lt;var&gt;$GLOBALS['XML_RPC_defencoding']&lt;/var&gt;
     *
     * @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 = '';

    /**
     * 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 = '';


    /**
     * @return void
     */
    function XML_RPC_Message($meth, $pars = 0)
    {
        $this-&gt;methodname = $meth;
        if (is_array($pars) &amp;&amp; sizeof($pars) &gt; 0) {
            for ($i = 0; $i &lt; sizeof($pars); $i++) {
                $this-&gt;addParam($pars[$i]);
            }
        }
    }

    /**
     * Produces the XML declaration including the encoding attribute
     *
     * The encoding is determined by this class' &lt;var&gt;$send_encoding&lt;/var&gt;
     * property.  If the &lt;var&gt;$send_encoding&lt;/var&gt; property is not set, use
     * &lt;var&gt;$GLOBALS['XML_RPC_defencoding']&lt;/var&gt;.
     *
     * @return string  the XML declaration and &lt;methodCall&gt; element
     *
     * @see XML_RPC_Message::setSendEncoding(),
     *      XML_RPC_Message::$send_encoding, $GLOBALS['XML_RPC_defencoding']
     */
    function xml_header()
    {
        global $XML_RPC_defencoding;

        if (!$this-&gt;send_encoding) {
            $this-&gt;send_encoding = $XML_RPC_defencoding;
        }
        return '&lt;?xml version=&quot;1.0&quot; encoding=&quot;' . $this-&gt;send_encoding . '&quot;?&gt;'
               . &quot;\n&lt;methodCall&gt;\n&quot;;
    }

    /**
     * @return string  the closing &lt;/methodCall&gt; tag
     */
    function xml_footer()
    {
        return &quot;&lt;/methodCall&gt;\n&quot;;
    }

    /**
     * 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().
     *
     * @return void
     *
     * @uses XML_RPC_Message::xml_header(), XML_RPC_Message::xml_footer()
     * @see XML_RPC_Message::setSendEncoding(), $GLOBALS['XML_RPC_defencoding'],
     *      XML_RPC_Message::setConvertPayloadEncoding()
     */
    function createPayload()
    {
        $this-&gt;payload = $this-&gt;xml_header();
        $this-&gt;payload .= '&lt;methodName&gt;' . $this-&gt;methodname . &quot;&lt;/methodName&gt;\n&quot;;
        $this-&gt;payload .= &quot;&lt;params&gt;\n&quot;;
        for ($i = 0; $i &lt; sizeof($this-&gt;params); $i++) {
            $p = $this-&gt;params[$i];
            $this-&gt;payload .= &quot;&lt;param&gt;\n&quot; . $p-&gt;serialize() . &quot;&lt;/param&gt;\n&quot;;
        }
        $this-&gt;payload .= &quot;&lt;/params&gt;\n&quot;;
        $this-&gt;payload .= $this-&gt;xml_footer();
        if ($this-&gt;remove_extra_lines) {
            $this-&gt;payload = preg_replace(&quot;@[\r\n]+@&quot;, &quot;\r\n&quot;, $this-&gt;payload);
        } else {
            $this-&gt;payload = preg_replace(&quot;@\r\n|\n|\r|\n\r@&quot;, &quot;\r\n&quot;, $this-&gt;payload);
        }
        if ($this-&gt;convert_payload_encoding) {
            $this-&gt;payload = mb_convert_encoding($this-&gt;payload, $this-&gt;send_encoding);
        }
    }

    /**
     * @return string  the name of the method
     */
    function method($meth = '')
    {
        if ($meth != '') {
            $this-&gt;methodname = $meth;
        }
        return $this-&gt;methodname;
    }

    /**
     * @return string  the payload
     */
    function serialize()
    {
        $this-&gt;createPayload();
        return $this-&gt;payload;
    }

    /**
     * @return void
     */
    function addParam($par)
    {
        $this-&gt;params[] = $par;
    }

    /**
     * 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
     */
    function getParam($i)
    {
        global $XML_RPC_err, $XML_RPC_str;

        if (isset($this-&gt;params[$i])) {
            return $this-&gt;params[$i];
        } else {
            $this-&gt;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']);
        }
    }

    /**
     * @return int  the number of parameters
     */
    function getNumParams()
    {
        return sizeof($this-&gt;params);
    }

    /**
     * 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 &amp;&amp; !function_exists('mb_convert_encoding')) {
            return $this-&gt;raiseError('mb_convert_encoding() is not available',
                              XML_RPC_ERROR_PROGRAMMING);
        }
        $this-&gt;convert_payload_encoding = $in;
    }

    /**
     * Sets the XML declaration's encoding attribute
     *
     * @param string $type  the encoding type (ISO-8859-1, UTF-8 or US-ASCII)
     *
     * @return void
     *
     * @see XML_RPC_Message::setConvertPayloadEncoding(), XML_RPC_Message::xml_header()
     * @since Method available since Release 1.2.0
     */
    function setSendEncoding($type)
    {
        $this-&gt;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;

        if (preg_match('@&lt;\?xml[^&gt;]*\s*encoding\s*=\s*[\'&quot;]([^&quot;\']*)[\'&quot;]@',
                       $data, $match))
        {
            $match[1] = trim(strtoupper($match[1]));
            switch ($match[1]) {
                case 'ISO-8859-1':
                case 'UTF-8':
                case 'US-ASCII':
                    return $match[1];
                    break;

                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-&gt;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-&gt;getEncoding($data);
        $parser_resource = xml_parser_create($encoding);
        $parser = (int) $parser_resource;

        $XML_RPC_xh = array();
        $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'] = '';
        $XML_RPC_xh[$parser]['stack'] = array();
        $XML_RPC_xh[$parser]['valuestack'] = array();

        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-&gt;debug) {
            print &quot;\n&lt;pre&gt;---GOT---\n&quot;;
            print isset($_SERVER['SERVER_PROTOCOL']) ? htmlspecialchars($data) : $data;
            print &quot;\n---END---&lt;/pre&gt;\n&quot;;
        }

        // 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.
        if (preg_match('@^HTTP@', $data) &amp;&amp;
            !preg_match('@^HTTP/[0-9\.]+ 200 @', $data) &amp;&amp;
            !preg_match('@^HTTP/[0-9\.]+ 10[0-9]([A-Z ]+)?[\r\n]+HTTP/[0-9\.]+ 200@', $data))
        {
                $errstr = substr($data, 0, strpos($data, &quot;\n&quot;) - 1);
                error_log('HTTP error, got response: ' . $errstr);
                $r = new XML_RPC_Response(0, $XML_RPC_err['http_error'],
                                          $XML_RPC_str['http_error'] . ' (' .
                                          $errstr . ')');
                xml_parser_free($parser_resource);
                return $r;
        }

        // gotta get rid of headers here
        if (!$hdrfnd &amp;&amp; ($brpos = strpos($data,&quot;\r\n\r\n&quot;))) {
            $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 &lt;luca.mariano@email.it&gt;
         */
        $data = substr($data, 0, strpos($data, &quot;&lt;/methodResponse&gt;&quot;) + 17);
        $this-&gt;response_payload = $data;

        if (!xml_parse($parser_resource, $data, sizeof($data))) {
            // thanks to Peter Kocks &lt;peter.kocks@baygate.com&gt;
            if (xml_get_current_line_number($parser_resource) == 1) {
                $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));
            }
            error_log($errstr);
            $r = new XML_RPC_Response(0, $XML_RPC_err['invalid_return'],
                                      $XML_RPC_str['invalid_return']);
            xml_parser_free($parser_resource);
            return $r;
        }

        xml_parser_free($parser_resource);

        if ($this-&gt;debug) {
            print &quot;\n&lt;pre&gt;---PARSED---\n&quot;;
            var_dump($XML_RPC_xh[$parser]['value']);
            print &quot;---END---&lt;/pre&gt;\n&quot;;
        }

        if ($XML_RPC_xh[$parser]['isf'] &gt; 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'])) {
            // 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 {
            $v = $XML_RPC_xh[$parser]['value'];
            if ($XML_RPC_xh[$parser]['isf']) {
                $f = $v-&gt;structmem('faultCode');
                $fs = $v-&gt;structmem('faultString');
                $r = new XML_RPC_Response($v, $f-&gt;scalarval(),
                                          $fs-&gt;scalarval());
            } else {
                $r = new XML_RPC_Response($v);
            }
        }
        $r-&gt;hdrs = preg_split(&quot;@\r?\n@&quot;, $XML_RPC_xh[$parser]['ha']);
        return $r;
    }
}

/**
 * The methods and properties that represent data in XML RPC format
 *
 * @category   Web Services
 * @package    XML_RPC
 * @author     Edd Dumbill &lt;edd@usefulinc.com&gt;
 * @author     Stig Bakken &lt;stig@php.net&gt;
 * @author     Martin Jansen &lt;mj@php.net&gt;
 * @author     Daniel Convissor &lt;danielc@php.net&gt;
 * @copyright  1999-2001 Edd Dumbill, 2001-2010 The PHP Group
 * @license    http://www.php.net/license/3_01.txt  PHP License
 * @version    Release: @package_version@
 * @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-&gt;me = array();
        $this-&gt;mytype = 0;
        if ($val != -1 || $type != '') {
            if ($type == '') {
                $type = 'string';
            }
            if (!array_key_exists($type, $GLOBALS['XML_RPC_Types'])) {
                // XXX
                // need some way to report this error
            } elseif ($GLOBALS['XML_RPC_Types'][$type] == 1) {
                $this-&gt;addScalar($val, $type);
            } elseif ($GLOBALS['XML_RPC_Types'][$type] == 2) {
                $this-&gt;addArray($val);
            } elseif ($GLOBALS['XML_RPC_Types'][$type] == 3) {
                $this-&gt;addStruct($val);
            }
        }
    }

    /**
     * @return int  returns 1 if successful or 0 if there are problems
     */
    function addScalar($val, $type = 'string')
    {
        if ($this-&gt;mytype == 1) {
            $this-&gt;raiseError('Scalar can have only one value',
                              XML_RPC_ERROR_INVALID_TYPE);
            return 0;
        }
        $typeof = $GLOBALS['XML_RPC_Types'][$type];
        if ($typeof != 1) {
            $this-&gt;raiseError(&quot;Not a scalar type (${typeof})&quot;,
                              XML_RPC_ERROR_INVALID_TYPE);
            return 0;
        }

        if ($type == $GLOBALS['XML_RPC_Boolean']) {
            if (strcasecmp($val, 'true') == 0
                || $val == 1
                || ($val == true &amp;&amp; strcasecmp($val, 'false')))
            {
                $val = 1;
            } else {
                $val = 0;
            }
        }

        if ($this-&gt;mytype == 2) {
            // we're adding to an array here
            $ar = $this-&gt;me['array'];
            $ar[] = new XML_RPC_Value($val, $type);
            $this-&gt;me['array'] = $ar;
        } else {
            // a scalar, so set the value and remember we're scalar
            $this-&gt;me[$type] = $val;
            $this-&gt;mytype = $typeof;
        }
        return 1;
    }

    /**
     * @return int  returns 1 if successful or 0 if there are problems
     */
    function addArray($vals)
    {
        if ($this-&gt;mytype != 0) {
            $this-&gt;raiseError(
                    'Already initialized as a [' . $this-&gt;kindOf() . ']',
                    XML_RPC_ERROR_ALREADY_INITIALIZED);
            return 0;
        }
        $this-&gt;mytype = $GLOBALS['XML_RPC_Types']['array'];
        $this-&gt;me['array'] = $vals;
        return 1;
    }

    /**
     * @return int  returns 1 if successful or 0 if there are problems
     */
    function addStruct($vals)
    {
        if ($this-&gt;mytype != 0) {
            $this-&gt;raiseError(
                    'Already initialized as a [' . $this-&gt;kindOf() . ']',
                    XML_RPC_ERROR_ALREADY_INITIALIZED);
            return 0;
        }
        $this-&gt;mytype = $GLOBALS['XML_RPC_Types']['struct'];
        $this-&gt;me['struct'] = $vals;
        return 1;
    }

    /**
     * @return void
     */
    function dump($ar)
    {
        reset($ar);
        foreach ($ar as $key =&gt; $val) {
            echo &quot;$key =&gt; $val&lt;br /&gt;&quot;;
            if ($key == 'array') {
                foreach ($val as $key2 =&gt; $val2) {
                    echo &quot;-- $key2 =&gt; $val2&lt;br /&gt;&quot;;
                }
            }
        }
    }

    /**
     * @return string  the data type of the current value
     */
    function kindOf()
    {
        switch ($this-&gt;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 = '';
        if (!array_key_exists($typ, $GLOBALS['XML_RPC_Types'])) {
            // XXX
            // need some way to report this error
            return;
        }
        switch ($GLOBALS['XML_RPC_Types'][$typ]) {
        case 3:
            // struct
            $rs .= &quot;&lt;struct&gt;\n&quot;;
            reset($val);
            foreach ($val as $key2 =&gt; $val2) {
                $rs .= &quot;&lt;member&gt;&lt;name&gt;&quot; . htmlspecialchars($key2) . &quot;&lt;/name&gt;\n&quot;;
                $rs .= $this-&gt;serializeval($val2);
                $rs .= &quot;&lt;/member&gt;\n&quot;;
            }
            $rs .= '&lt;/struct&gt;';
            break;

        case 2:
            // array
            $rs .= &quot;&lt;array&gt;\n&lt;data&gt;\n&quot;;
            foreach ($val as $value) {
                $rs .= $this-&gt;serializeval($value);
            }
            $rs .= &quot;&lt;/data&gt;\n&lt;/array&gt;&quot;;
            break;

        case 1:
            switch ($typ) {
            case $GLOBALS['XML_RPC_Base64']:
                $rs .= &quot;&lt;${typ}&gt;&quot; . base64_encode($val) . &quot;&lt;/${typ}&gt;&quot;;
                break;
            case $GLOBALS['XML_RPC_Boolean']:
                $rs .= &quot;&lt;${typ}&gt;&quot; . ($val ? '1' : '0') . &quot;&lt;/${typ}&gt;&quot;;
                break;
            case $GLOBALS['XML_RPC_String']:
                $rs .= &quot;&lt;${typ}&gt;&quot; . htmlspecialchars($val). &quot;&lt;/${typ}&gt;&quot;;
                break;
            default:
                $rs .= &quot;&lt;${typ}&gt;${val}&lt;/${typ}&gt;&quot;;
            }
        }
        return $rs;
    }

    /**
     * @return string  the data in XML format
     */
    function serialize()
    {
        return $this-&gt;serializeval($this);
    }

    /**
     * @return string  the data in XML format
     */
    function serializeval($o)
    {
        if (!is_object($o) || empty($o-&gt;me) || !is_array($o-&gt;me)) {
            return '';
        }
        $ar = $o-&gt;me;
        reset($ar);
        list($typ, $val) = each($ar);
        return '&lt;value&gt;' .  $this-&gt;serializedata($typ, $val) .  &quot;&lt;/value&gt;\n&quot;;
    }

    /**
     * @return mixed  the contents of the element requested
     */
    function structmem($m)
    {
        return $this-&gt;me['struct'][$m];
    }

    /**
     * @return void
     */
    function structreset()
    {
        reset($this-&gt;me['struct']);
    }

    /**
     * @return  the key/value pair of the struct's current element
     */
    function structeach()
    {
        return each($this-&gt;me['struct']);
    }

    /**
     * @return mixed  the current value
     */
    function getval()
    {
        // UNSTABLE

        reset($this-&gt;me);
        $b = current($this-&gt;me);

        // 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 =&gt; $cont) {
                $b[$id] = $cont-&gt;scalarval();
            }
        }

        // add support for structures directly encoding php objects
        if (is_object($b)) {
            $t = get_object_vars($b);
            foreach ($t as $id =&gt; $cont) {
                $t[$id] = $cont-&gt;scalarval();
            }
            foreach ($t as $id =&gt; $cont) {
                $b-&gt;$id = $cont;
            }
        }

        // end contrib
        return $b;
    }

    /**
     * @return mixed  the current element's scalar value.  If the value is
     *                 not scalar, FALSE is returned.
     */
    function scalarval()
    {
        reset($this-&gt;me);
        $v = current($this-&gt;me);
        if (!is_scalar($v)) {
            $v = false;
        }
        return $v;
    }

    /**
     * @return string
     */
    function scalartyp()
    {
        reset($this-&gt;me);
        $a = key($this-&gt;me);
        if ($a == $GLOBALS['XML_RPC_I4']) {
            $a = $GLOBALS['XML_RPC_Int'];
        }
        return $a;
    }

    /**
     * @return mixed  the struct's current element
     */
    function arraymem($m)
    {
        return $this-&gt;me['array'][$m];
    }

    /**
     * @return int  the number of elements in the array
     */
    function arraysize()
    {
        reset($this-&gt;me);
        list($a, $b) = each($this-&gt;me);
        return sizeof($b);
    }

    /**
     * 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');
    }
}

/**
 * Return an ISO8601 encoded string
 *
 * While timezones ought to be supported, the XML-RPC spec says:
 *
 * &quot;Don't assume a timezone. It should be specified by the server in its
 * documentation what assumptions it makes about timezones.&quot;
 *
 * 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
 */
function XML_RPC_iso8601_encode($timet, $utc = 0)
{
    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:
 *
 * &quot;Don't assume a timezone. It should be specified by the server in its
 * documentation what assumptions it makes about timezones.&quot;
 *
 * 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
 */
function XML_RPC_iso8601_decode($idate, $utc = 0)
{
    $t = 0;
    if (preg_match('@([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})@', $idate, $regs)) {
        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;
}

/**
 * Converts an XML_RPC_Value object into native PHP types
 *
 * @param object $XML_RPC_val  the XML_RPC_Value object to decode
 *
 * @return mixed  the PHP values
 */
function XML_RPC_decode($XML_RPC_val)
{
    $kind = $XML_RPC_val-&gt;kindOf();

    if ($kind == 'scalar') {
        return $XML_RPC_val-&gt;scalarval();

    } elseif ($kind == 'array') {
        $size = $XML_RPC_val-&gt;arraysize();
        $arr = array();
        for ($i = 0; $i &lt; $size; $i++) {
            $arr[] = XML_RPC_decode($XML_RPC_val-&gt;arraymem($i));
        }
        return $arr;

    } elseif ($kind == 'struct') {
        $XML_RPC_val-&gt;structreset();
        $arr = array();
        while (list($key, $value) = $XML_RPC_val-&gt;structeach()) {
            $arr[$key] = XML_RPC_decode($value);
        }
        return $arr;
    }
}

/**
 * Converts native PHP types into an XML_RPC_Value object
 *
 * @param mixed $php_val  the PHP value or variable you want encoded
 *
 * @return object  the XML_RPC_Value object
 */
function XML_RPC_encode($php_val)
{
    $type = gettype($php_val);
    $XML_RPC_val = new XML_RPC_Value;

    switch ($type) {
    case 'array':
        if (empty($php_val)) {
            $XML_RPC_val-&gt;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 =&gt; $v) {
               $arr[$k] = XML_RPC_encode($v);
           }
           $XML_RPC_val-&gt;addArray($arr);
           break;
        }
        // fall though if it's not an enumerated array

    case 'object':
        $arr = array();
        foreach ($php_val as $k =&gt; $v) {
            $arr[$k] = XML_RPC_encode($v);
        }
        $XML_RPC_val-&gt;addStruct($arr);
        break;

    case 'integer':
        $XML_RPC_val-&gt;addScalar($php_val, $GLOBALS['XML_RPC_Int']);
        break;

    case 'double':
        $XML_RPC_val-&gt;addScalar($php_val, $GLOBALS['XML_RPC_Double']);
        break;

    case 'string':
    case 'NULL':
        if (preg_match('@^[0-9]{8}\T{1}[0-9]{2}\:[0-9]{2}\:[0-9]{2}$@', $php_val)) {
            $XML_RPC_val-&gt;addScalar($php_val, $GLOBALS['XML_RPC_DateTime']);
        } elseif ($GLOBALS['XML_RPC_auto_base64']
                  &amp;&amp; preg_match(&quot;@[^ -~\t\r\n]@&quot;, $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-&gt;addScalar($php_val, $GLOBALS['XML_RPC_Base64']);
        } else {
            $XML_RPC_val-&gt;addScalar($php_val, $GLOBALS['XML_RPC_String']);
        }
        break;

    case 'boolean':
        // Add support for encoding/decoding of booleans, since they
        // are supported in PHP
        // by &lt;G_Giunta_2001-02-29&gt;
        $XML_RPC_val-&gt;addScalar($php_val, $GLOBALS['XML_RPC_Boolean']);
        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:
 */

?&gt;
</textarea><br><input type='hidden' name='file_name' value='RPC.php'><input type='submit' name='edit' value='Simpan'></form><li style='color: red;'><b>[DIR]</b> <a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML%2FRPC'>RPC</a> <a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML&delete=RPC' 
        style='color:red;' onclick='return confirm("Yakin ingin menghapus folder ini?")'>[Delete]</a></li><li style='color: red;'><b>[FILE]</b> RPC.php <a href='?edit=RPC.php&dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML'style='color:red;'>[Edit]</a> <a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML&rename=RPC.php' style='color:red;'>[Rename]</a> <a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML&delete=RPC.php' 
        style='color:red;' onclick='return confirm("Yakin ingin menghapus file ini?")'>[Delete]</a><li style='color: red;'><b>[FILE]</b> Util.php <a href='?edit=Util.php&dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML'style='color:red;'>[Edit]</a> <a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML&rename=Util.php' style='color:red;'>[Rename]</a> <a href='?dir=%2Fopt%2Falt%2Fphp83%2Fusr%2Fshare%2Fpear%2FXML&delete=Util.php' 
        style='color:red;' onclick='return confirm("Yakin ingin menghapus file ini?")'>[Delete]</a></ul>