library/Zend/XmlRpc/Client.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_XmlRpc
  17  * @subpackage Client
  18  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  19  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  20  */
  21
  22
  23 /**
  24  * For handling the HTTP connection to the XML-RPC service
  25  * @see Zend_Http_Client
  26  */
  27 require_once 'Zend/Http/Client.php';
  28
  29 /**
  30  * Enables object chaining for calling namespaced XML-RPC methods.
  31  * @see Zend_XmlRpc_Client_ServerProxy
  32  */
  33 require_once 'Zend/XmlRpc/Client/ServerProxy.php';
  34
  35 /**
  36  * Introspects remote servers using the XML-RPC de facto system.* methods
  37  * @see Zend_XmlRpc_Client_ServerIntrospection
  38  */
  39 require_once 'Zend/XmlRpc/Client/ServerIntrospection.php';
  40
  41 /**
  42  * Represent a native XML-RPC value, used both in sending parameters
  43  * to methods and as the parameters retrieve from method calls
  44  * @see Zend_XmlRpc_Value
  45  */
  46 require_once 'Zend/XmlRpc/Value.php';
  47
  48 /**
  49  * XML-RPC Request
  50  * @see Zend_XmlRpc_Request
  51  */
  52 require_once 'Zend/XmlRpc/Request.php';
  53
  54 /**
  55  * XML-RPC Response
  56  * @see Zend_XmlRpc_Response
  57  */
  58 require_once 'Zend/XmlRpc/Response.php';
  59
  60 /**
  61  * XML-RPC Fault
  62  * @see Zend_XmlRpc_Fault
  63  */
  64 require_once 'Zend/XmlRpc/Fault.php';
  65
  66
  67 /**
  68  * An XML-RPC client implementation
  69  *
  70  * @category   Zend
  71  * @package    Zend_XmlRpc
  72  * @subpackage Client
  73  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  74  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  75  */
  76 class Zend_XmlRpc_Client
  77 {
  78     /**
  79      * Full address of the XML-RPC service
  80      * @var string
  81      * @example http://time.xmlrpc.com/RPC2
  82      */
  83     protected $_serverAddress;
  84
  85     /**
  86      * HTTP Client to use for requests
  87      * @var Zend_Http_Client
  88      */
  89     protected $_httpClient = null;
  90
  91     /**
  92      * Introspection object
  93      * @var Zend_Http_Client_Introspector
  94      */
  95     protected $_introspector = null;
  96
  97     /**
  98      * Request of the last method call
  99      * @var Zend_XmlRpc_Request
 100      */
 101     protected $_lastRequest = null;
 102
 103     /**
 104      * Response received from the last method call
 105      * @var Zend_XmlRpc_Response
 106      */
 107     protected $_lastResponse = null;
 108
 109     /**
 110      * Proxy object for more convenient method calls
 111      * @var array of Zend_XmlRpc_Client_ServerProxy
 112      */
 113     protected $_proxyCache = array();
 114
 115     /**
 116      * Flag for skipping system lookup
 117      * @var bool
 118      */
 119     protected $_skipSystemLookup = false;
 120
 121     /**
 122      * Create a new XML-RPC client to a remote server
 123      *
 124      * @param  string $server      Full address of the XML-RPC service
 125      *                             (e.g. http://time.xmlrpc.com/RPC2)
 126      * @param  Zend_Http_Client $httpClient HTTP Client to use for requests
 127      * @return void
 128      */
 129     public function __construct($server, Zend_Http_Client $httpClient = null)
 130     {
 131         if ($httpClient === null) {
 132             $this->_httpClient = new Zend_Http_Client();
 133         } else {
 134             $this->_httpClient = $httpClient;
 135         }
 136
 137         $this->_introspector  = new Zend_XmlRpc_Client_ServerIntrospection($this);
 138         $this->_serverAddress = $server;
 139     }
 140
 141
 142     /**
 143      * Sets the HTTP client object to use for connecting the XML-RPC server.
 144      *
 145      * @param  Zend_Http_Client $httpClient
 146      * @return Zend_Http_Client
 147      */
 148     public function setHttpClient(Zend_Http_Client $httpClient)
 149     {
 150         return $this->_httpClient = $httpClient;
 151     }
 152
 153
 154     /**
 155      * Gets the HTTP client object.
 156      *
 157      * @return Zend_Http_Client
 158      */
 159     public function getHttpClient()
 160     {
 161         return $this->_httpClient;
 162     }
 163
 164
 165     /**
 166      * Sets the object used to introspect remote servers
 167      *
 168      * @param  Zend_XmlRpc_Client_ServerIntrospection
 169      * @return Zend_XmlRpc_Client_ServerIntrospection
 170      */
 171     public function setIntrospector(Zend_XmlRpc_Client_ServerIntrospection $introspector)
 172     {
 173         return $this->_introspector = $introspector;
 174     }
 175
 176
 177     /**
 178      * Gets the introspection object.
 179      *
 180      * @return Zend_XmlRpc_Client_ServerIntrospection
 181      */
 182     public function getIntrospector()
 183     {
 184         return $this->_introspector;
 185     }
 186
 187
 188    /**
 189      * The request of the last method call
 190      *
 191      * @return Zend_XmlRpc_Request
 192      */
 193     public function getLastRequest()
 194     {
 195         return $this->_lastRequest;
 196     }
 197
 198
 199     /**
 200      * The response received from the last method call
 201      *
 202      * @return Zend_XmlRpc_Response
 203      */
 204     public function getLastResponse()
 205     {
 206         return $this->_lastResponse;
 207     }
 208
 209
 210     /**
 211      * Returns a proxy object for more convenient method calls
 212      *
 213      * @param $namespace  Namespace to proxy or empty string for none
 214      * @return Zend_XmlRpc_Client_ServerProxy
 215      */
 216     public function getProxy($namespace = '')
 217     {
 218         if (empty($this->_proxyCache[$namespace])) {
 219             $proxy = new Zend_XmlRpc_Client_ServerProxy($this, $namespace);
 220             $this->_proxyCache[$namespace] = $proxy;
 221         }
 222         return $this->_proxyCache[$namespace];
 223     }
 224
 225     /**
 226      * Set skip system lookup flag
 227      *
 228      * @param  bool $flag
 229      * @return Zend_XmlRpc_Client
 230      */
 231     public function setSkipSystemLookup($flag = true)
 232     {
 233         $this->_skipSystemLookup = (bool) $flag;
 234         return $this;
 235     }
 236
 237     /**
 238      * Skip system lookup when determining if parameter should be array or struct?
 239      *
 240      * @return bool
 241      */
 242     public function skipSystemLookup()
 243     {
 244         return $this->_skipSystemLookup;
 245     }
 246
 247     /**
 248      * Perform an XML-RPC request and return a response.
 249      *
 250      * @param Zend_XmlRpc_Request $request
 251      * @param null|Zend_XmlRpc_Response $response
 252      * @return void
 253      * @throws Zend_XmlRpc_Client_HttpException
 254      */
 255     public function doRequest($request, $response = null)
 256     {
 257         $this->_lastRequest = $request;
 258
 259         iconv_set_encoding('input_encoding', 'UTF-8');
 260         iconv_set_encoding('output_encoding', 'UTF-8');
 261         iconv_set_encoding('internal_encoding', 'UTF-8');
 262
 263         $http = $this->getHttpClient();
 264         if($http->getUri() === null) {
 265             $http->setUri($this->_serverAddress);
 266         }
 267
 268         $http->setHeaders(array(
 269             'Content-Type: text/xml; charset=utf-8',
 270             'User-Agent: Zend_XmlRpc_Client',
 271             'Accept: text/xml',
 272         ));
 273
 274         $xml = $this->_lastRequest->__toString();
 275         $http->setRawData($xml);
 276         $httpResponse = $http->request(Zend_Http_Client::POST);
 277
 278         if (! $httpResponse->isSuccessful()) {
 279             /**
 280              * Exception thrown when an HTTP error occurs
 281              * @see Zend_XmlRpc_Client_HttpException
 282              */
 283             require_once 'Zend/XmlRpc/Client/HttpException.php';
 284             throw new Zend_XmlRpc_Client_HttpException(
 285                                     $httpResponse->getMessage(),
 286                                     $httpResponse->getStatus());
 287         }
 288
 289         if ($response === null) {
 290             $response = new Zend_XmlRpc_Response();
 291         }
 292         $this->_lastResponse = $response;
 293         $this->_lastResponse->loadXml($httpResponse->getBody());
 294     }
 295
 296     /**
 297      * Send an XML-RPC request to the service (for a specific method)
 298      *
 299      * @param  string $method Name of the method we want to call
 300      * @param  array $params Array of parameters for the method
 301      * @return mixed
 302      * @throws Zend_XmlRpc_Client_FaultException
 303      */
 304     public function call($method, $params=array())
 305     {
 306         if (!$this->skipSystemLookup() && ('system.' != substr($method, 0, 7))) {
 307             // Ensure empty array/struct params are cast correctly
 308             // If system.* methods are not available, bypass. (ZF-2978)
 309             $success = true;
 310             try {
 311                 $signatures = $this->getIntrospector()->getMethodSignature($method);
 312             } catch (Zend_XmlRpc_Exception $e) {
 313                 $success = false;
 314             }
 315             if ($success) {
 316                 foreach ($params as $key => $param) {
 317                     if (is_array($param) && empty($param)) {
 318                         $type = 'array';
 319                         foreach ($signatures as $signature) {
 320                             if (!is_array($signature)) {
 321                                 continue;
 322                             }
 323                             if (array_key_exists($key + 1, $signature)) {
 324                                 $type = $signature[$key + 1];
 325                                 $type = (in_array($type, array('array', 'struct'))) ? $type : 'array';
 326                                 break;
 327                             }
 328                         }
 329                         $params[$key] = array(
 330                             'type'  => $type,
 331                             'value' => $param
 332                         );
 333                     }
 334                 }
 335             }
 336         }
 337
 338         $request = new Zend_XmlRpc_Request($method, $params);
 339
 340         $this->doRequest($request);
 341
 342         if ($this->_lastResponse->isFault()) {
 343             $fault = $this->_lastResponse->getFault();
 344             /**
 345              * Exception thrown when an XML-RPC fault is returned
 346              * @see Zend_XmlRpc_Client_FaultException
 347              */
 348             require_once 'Zend/XmlRpc/Client/FaultException.php';
 349             throw new Zend_XmlRpc_Client_FaultException($fault->getMessage(),
 350                                                         $fault->getCode());
 351         }
 352
 353         return $this->_lastResponse->getReturnValue();
 354     }
 355 }