C:/xampp/htdocs/moodle/lib/zend/Zend/XmlRpc/Client.php

Go to the documentation of this file.

<?php
require_once 'Zend/Http/Client.php';

require_once 'Zend/XmlRpc/Client/ServerProxy.php';

require_once 'Zend/XmlRpc/Client/ServerIntrospection.php';

require_once 'Zend/XmlRpc/Value.php';

require_once 'Zend/XmlRpc/Request.php';

require_once 'Zend/XmlRpc/Response.php';

require_once 'Zend/XmlRpc/Fault.php';


class Zend_XmlRpc_Client
{
    protected $_serverAddress;

    protected $_httpClient = null;

    protected $_introspector = null;

    protected $_lastRequest = null;

    protected $_lastResponse = null;

    protected $_proxyCache = array();

    protected $_skipSystemLookup = false;

    public function __construct($server, Zend_Http_Client $httpClient = null)
    {
        if ($httpClient === null) {
            $this->_httpClient = new Zend_Http_Client();
        } else {
            $this->_httpClient = $httpClient;
        }

        $this->_introspector  = new Zend_XmlRpc_Client_ServerIntrospection($this);
        $this->_serverAddress = $server;
    }


    public function setHttpClient(Zend_Http_Client $httpClient)
    {
        return $this->_httpClient = $httpClient;
    }


    public function getHttpClient()
    {
        return $this->_httpClient;
    }


    public function setIntrospector(Zend_XmlRpc_Client_ServerIntrospection $introspector)
    {
        return $this->_introspector = $introspector;
    }


    public function getIntrospector()
    {
        return $this->_introspector;
    }


    public function getLastRequest()
    {
        return $this->_lastRequest;
    }


    public function getLastResponse()
    {
        return $this->_lastResponse;
    }


    public function getProxy($namespace = '')
    {
        if (empty($this->_proxyCache[$namespace])) {
            $proxy = new Zend_XmlRpc_Client_ServerProxy($this, $namespace);
            $this->_proxyCache[$namespace] = $proxy;
        }
        return $this->_proxyCache[$namespace];
    }

    public function setSkipSystemLookup($flag = true)
    {
        $this->_skipSystemLookup = (bool) $flag;
        return $this;
    }

    public function skipSystemLookup()
    {
        return $this->_skipSystemLookup;
    }

    public function doRequest($request, $response = null)
    {
        $this->_lastRequest = $request;

        iconv_set_encoding('input_encoding', 'UTF-8');
        iconv_set_encoding('output_encoding', 'UTF-8');
        iconv_set_encoding('internal_encoding', 'UTF-8');

        $http = $this->getHttpClient();
        if($http->getUri() === null) {
            $http->setUri($this->_serverAddress);
        }

        $http->setHeaders(array(
            'Content-Type: text/xml; charset=utf-8',
            'Accept: text/xml',
        ));

        if ($http->getHeader('user-agent') === null) {
            $http->setHeaders(array('User-Agent: Zend_XmlRpc_Client'));
        }

        $xml = $this->_lastRequest->__toString();
        $http->setRawData($xml);
        $httpResponse = $http->request(Zend_Http_Client::POST);

        if (! $httpResponse->isSuccessful()) {
            require_once 'Zend/XmlRpc/Client/HttpException.php';
            throw new Zend_XmlRpc_Client_HttpException(
                                    $httpResponse->getMessage(),
                                    $httpResponse->getStatus());
        }

        if ($response === null) {
            $response = new Zend_XmlRpc_Response();
        }
        $this->_lastResponse = $response;
        $this->_lastResponse->loadXml($httpResponse->getBody());
    }

    public function call($method, $params=array())
    {
        if (!$this->skipSystemLookup() && ('system.' != substr($method, 0, 7))) {
            // Ensure empty array/struct params are cast correctly
            // If system.* methods are not available, bypass. (ZF-2978)
            $success = true;
            try {
                $signatures = $this->getIntrospector()->getMethodSignature($method);
            } catch (Zend_XmlRpc_Exception $e) {
                $success = false;
            }
            if ($success) {
                $validTypes = array(
                    Zend_XmlRpc_Value::XMLRPC_TYPE_ARRAY,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_BASE64,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_BOOLEAN,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_DATETIME,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_DOUBLE,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_I4,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_INTEGER,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_NIL,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_STRING,
                    Zend_XmlRpc_Value::XMLRPC_TYPE_STRUCT,
                );

                if (!is_array($params)) {
                    $params = array($params);
                }
                foreach ($params as $key => $param) {

                    if ($param instanceof Zend_XmlRpc_Value) {
                        continue;
                    }

                    $type = Zend_XmlRpc_Value::AUTO_DETECT_TYPE;
                    foreach ($signatures as $signature) {
                        if (!is_array($signature)) {
                            continue;
                        }

                        if (isset($signature['parameters'][$key])) {
                            $type = $signature['parameters'][$key];
                            $type = in_array($type, $validTypes) ? $type : Zend_XmlRpc_Value::AUTO_DETECT_TYPE;
                        }
                    }

                    $params[$key] = Zend_XmlRpc_Value::getXmlRpcValue($param, $type);
                }
            }
        }

        $request = $this->_createRequest($method, $params);

        $this->doRequest($request);

        if ($this->_lastResponse->isFault()) {
            $fault = $this->_lastResponse->getFault();
            require_once 'Zend/XmlRpc/Client/FaultException.php';
            throw new Zend_XmlRpc_Client_FaultException($fault->getMessage(),
                                                        $fault->getCode());
        }

        return $this->_lastResponse->getReturnValue();
    }

    protected function _createRequest($method, $params)
    {
        return new Zend_XmlRpc_Request($method, $params);
    }
}