[Summary view] [Print] [Text view]

   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 [email protected] so we can send you a copy immediately.
  14   *
  15   * @category   Zend
  16   * @package    Zend_Controller
  17   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  18   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  19   */
  20  
  21  /**
  22   * Zend_XmlRpc_Value
  23   */
  24  require_once 'Zend/XmlRpc/Value.php';
  25  
  26  /**
  27   * Zend_XmlRpc_Fault
  28   */
  29  require_once 'Zend/XmlRpc/Fault.php';
  30  
  31  /**
  32   * XmlRpc Request object
  33   *
  34   * Encapsulates an XmlRpc request, holding the method call and all parameters.
  35   * Provides accessors for these, as well as the ability to load from XML and to
  36   * create the XML request string.
  37   *
  38   * Additionally, if errors occur setting the method or parsing XML, a fault is
  39   * generated and stored in {@link $_fault}; developers may check for it using
  40   * {@link isFault()} and {@link getFault()}.
  41   *
  42   * @category Zend
  43   * @package  Zend_XmlRpc
  44   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  45   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  46   * @version $Id$
  47   */
  48  class Zend_XmlRpc_Request
  49  {
  50      /**
  51       * Request character encoding
  52       * @var string
  53       */
  54      protected $_encoding = 'UTF-8';
  55  
  56      /**
  57       * Method to call
  58       * @var string
  59       */
  60      protected $_method;
  61  
  62      /**
  63       * XML request
  64       * @var string
  65       */
  66      protected $_xml;
  67  
  68      /**
  69       * Method parameters
  70       * @var array
  71       */
  72      protected $_params = array();
  73  
  74      /**
  75       * Fault object, if any
  76       * @var Zend_XmlRpc_Fault
  77       */
  78      protected $_fault = null;
  79  
  80      /**
  81       * XML-RPC type for each param
  82       * @var array
  83       */
  84      protected $_types = array();
  85  
  86      /**
  87       * XML-RPC request params
  88       * @var array
  89       */
  90      protected $_xmlRpcParams = array();
  91  
  92      /**
  93       * Create a new XML-RPC request
  94       *
  95       * @param string $method (optional)
  96       * @param array $params  (optional)
  97       */
  98      public function __construct($method = null, $params = null)
  99      {
 100          if ($method !== null) {
 101              $this->setMethod($method);
 102          }
 103  
 104          if ($params !== null) {
 105              $this->setParams($params);
 106          }
 107      }
 108  
 109  
 110      /**
 111       * Set encoding to use in request
 112       *
 113       * @param string $encoding
 114       * @return Zend_XmlRpc_Request
 115       */
 116      public function setEncoding($encoding)
 117      {
 118          $this->_encoding = $encoding;
 119          Zend_XmlRpc_Value::setEncoding($encoding);
 120          return $this;
 121      }
 122  
 123      /**
 124       * Retrieve current request encoding
 125       *
 126       * @return string
 127       */
 128      public function getEncoding()
 129      {
 130          return $this->_encoding;
 131      }
 132  
 133      /**
 134       * Set method to call
 135       *
 136       * @param string $method
 137       * @return boolean Returns true on success, false if method name is invalid
 138       */
 139      public function setMethod($method)
 140      {
 141          if (!is_string($method) || !preg_match('/^[a-z0-9_.:\/]+$/i', $method)) {
 142              $this->_fault = new Zend_XmlRpc_Fault(634, 'Invalid method name ("' . $method . '")');
 143              $this->_fault->setEncoding($this->getEncoding());
 144              return false;
 145          }
 146  
 147          $this->_method = $method;
 148          return true;
 149      }
 150  
 151      /**
 152       * Retrieve call method
 153       *
 154       * @return string
 155       */
 156      public function getMethod()
 157      {
 158          return $this->_method;
 159      }
 160  
 161      /**
 162       * Add a parameter to the parameter stack
 163       *
 164       * Adds a parameter to the parameter stack, associating it with the type
 165       * $type if provided
 166       *
 167       * @param mixed $value
 168       * @param string $type Optional; type hinting
 169       * @return void
 170       */
 171      public function addParam($value, $type = null)
 172      {
 173          $this->_params[] = $value;
 174          if (null === $type) {
 175              // Detect type if not provided explicitly
 176              if ($value instanceof Zend_XmlRpc_Value) {
 177                  $type = $value->getType();
 178              } else {
 179                  $xmlRpcValue = Zend_XmlRpc_Value::getXmlRpcValue($value);
 180                  $type        = $xmlRpcValue->getType();
 181              }
 182          }
 183          $this->_types[]  = $type;
 184          $this->_xmlRpcParams[] = array('value' => $value, 'type' => $type);
 185      }
 186  
 187      /**
 188       * Set the parameters array
 189       *
 190       * If called with a single, array value, that array is used to set the
 191       * parameters stack. If called with multiple values or a single non-array
 192       * value, the arguments are used to set the parameters stack.
 193       *
 194       * Best is to call with array of the format, in order to allow type hinting
 195       * when creating the XMLRPC values for each parameter:
 196       * <code>
 197       * $array = array(
 198       *     array(
 199       *         'value' => $value,
 200       *         'type'  => $type
 201       *     )[, ... ]
 202       * );
 203       * </code>
 204       *
 205       * @access public
 206       * @return void
 207       */
 208      public function setParams()
 209      {
 210          $argc = func_num_args();
 211          $argv = func_get_args();
 212          if (0 == $argc) {
 213              return;
 214          }
 215  
 216          if ((1 == $argc) && is_array($argv[0])) {
 217              $params     = array();
 218              $types      = array();
 219              $wellFormed = true;
 220              foreach ($argv[0] as $arg) {
 221                  if (!is_array($arg) || !isset($arg['value'])) {
 222                      $wellFormed = false;
 223                      break;
 224                  }
 225                  $params[] = $arg['value'];
 226  
 227                  if (!isset($arg['type'])) {
 228                      $xmlRpcValue = Zend_XmlRpc_Value::getXmlRpcValue($arg['value']);
 229                      $arg['type'] = $xmlRpcValue->getType();
 230                  }
 231                  $types[] = $arg['type'];
 232              }
 233              if ($wellFormed) {
 234                  $this->_xmlRpcParams = $argv[0];
 235                  $this->_params = $params;
 236                  $this->_types  = $types;
 237              } else {
 238                  $this->_params = $argv[0];
 239                  $this->_types  = array();
 240                  $xmlRpcParams  = array();
 241                  foreach ($argv[0] as $arg) {
 242                      if ($arg instanceof Zend_XmlRpc_Value) {
 243                          $type = $arg->getType();
 244                      } else {
 245                          $xmlRpcValue = Zend_XmlRpc_Value::getXmlRpcValue($arg);
 246                          $type        = $xmlRpcValue->getType();
 247                      }
 248                      $xmlRpcParams[] = array('value' => $arg, 'type' => $type);
 249                      $this->_types[] = $type;
 250                  }
 251                  $this->_xmlRpcParams = $xmlRpcParams;
 252              }
 253              return;
 254          }
 255  
 256          $this->_params = $argv;
 257          $this->_types  = array();
 258          $xmlRpcParams  = array();
 259          foreach ($argv as $arg) {
 260              if ($arg instanceof Zend_XmlRpc_Value) {
 261                  $type = $arg->getType();
 262              } else {
 263                  $xmlRpcValue = Zend_XmlRpc_Value::getXmlRpcValue($arg);
 264                  $type        = $xmlRpcValue->getType();
 265              }
 266              $xmlRpcParams[] = array('value' => $arg, 'type' => $type);
 267              $this->_types[] = $type;
 268          }
 269          $this->_xmlRpcParams = $xmlRpcParams;
 270      }
 271  
 272      /**
 273       * Retrieve the array of parameters
 274       *
 275       * @return array
 276       */
 277      public function getParams()
 278      {
 279          return $this->_params;
 280      }
 281  
 282      /**
 283       * Return parameter types
 284       *
 285       * @return array
 286       */
 287      public function getTypes()
 288      {
 289          return $this->_types;
 290      }
 291  
 292      /**
 293       * Load XML and parse into request components
 294       *
 295       * @param string $request
 296       * @return boolean True on success, false if an error occurred.
 297       */
 298      public function loadXml($request)
 299      {
 300          if (!is_string($request)) {
 301              $this->_fault = new Zend_XmlRpc_Fault(635);
 302              $this->_fault->setEncoding($this->getEncoding());
 303              return false;
 304          }
 305  
 306          // @see ZF-12293 - disable external entities for security purposes
 307          $loadEntities = libxml_disable_entity_loader(true);
 308          try {
 309              $xml = new SimpleXMLElement($request);
 310          } catch (Exception $e) {
 311              // Not valid XML
 312              $this->_fault = new Zend_XmlRpc_Fault(631);
 313              $this->_fault->setEncoding($this->getEncoding());
 314              libxml_disable_entity_loader($loadEntities);
 315              return false;
 316          }
 317  
 318          // Check for method name
 319          if (empty($xml->methodName)) {
 320              // Missing method name
 321              $this->_fault = new Zend_XmlRpc_Fault(632);
 322              $this->_fault->setEncoding($this->getEncoding());
 323              libxml_disable_entity_loader($loadEntities);
 324              return false;
 325          }
 326  
 327          $this->_method = (string) $xml->methodName;
 328  
 329          // Check for parameters
 330          if (!empty($xml->params)) {
 331              $types = array();
 332              $argv  = array();
 333              foreach ($xml->params->children() as $param) {
 334                  if (!isset($param->value)) {
 335                      $this->_fault = new Zend_XmlRpc_Fault(633);
 336                      $this->_fault->setEncoding($this->getEncoding());
 337                      libxml_disable_entity_loader($loadEntities);
 338                      return false;
 339                  }
 340  
 341                  try {
 342                      $param   = Zend_XmlRpc_Value::getXmlRpcValue($param->value, Zend_XmlRpc_Value::XML_STRING);
 343                      $types[] = $param->getType();
 344                      $argv[]  = $param->getValue();
 345                  } catch (Exception $e) {
 346                      $this->_fault = new Zend_XmlRpc_Fault(636);
 347                      $this->_fault->setEncoding($this->getEncoding());
 348                      libxml_disable_entity_loader($loadEntities);
 349                      return false;
 350                  }
 351              }
 352  
 353              $this->_types  = $types;
 354              $this->_params = $argv;
 355          }
 356  
 357          libxml_disable_entity_loader($loadEntities);
 358          $this->_xml = $request;
 359  
 360          return true;
 361      }
 362  
 363      /**
 364       * Does the current request contain errors and should it return a fault
 365       * response?
 366       *
 367       * @return boolean
 368       */
 369      public function isFault()
 370      {
 371          return $this->_fault instanceof Zend_XmlRpc_Fault;
 372      }
 373  
 374      /**
 375       * Retrieve the fault response, if any
 376       *
 377       * @return null|Zend_XmlRpc_Fault
 378       */
 379      public function getFault()
 380      {
 381          return $this->_fault;
 382      }
 383  
 384      /**
 385       * Retrieve method parameters as XMLRPC values
 386       *
 387       * @return array
 388       */
 389      protected function _getXmlRpcParams()
 390      {
 391          $params = array();
 392          if (is_array($this->_xmlRpcParams)) {
 393              foreach ($this->_xmlRpcParams as $param) {
 394                  $value = $param['value'];
 395                  $type  = isset($param['type']) ? $param['type'] : Zend_XmlRpc_Value::AUTO_DETECT_TYPE;
 396  
 397                  if (!$value instanceof Zend_XmlRpc_Value) {
 398                      $value = Zend_XmlRpc_Value::getXmlRpcValue($value, $type);
 399                  }
 400                  $params[] = $value;
 401              }
 402          }
 403  
 404          return $params;
 405      }
 406  
 407      /**
 408       * Create XML request
 409       *
 410       * @return string
 411       */
 412      public function saveXml()
 413      {
 414          $args   = $this->_getXmlRpcParams();
 415          $method = $this->getMethod();
 416  
 417          $generator = Zend_XmlRpc_Value::getGenerator();
 418          $generator->openElement('methodCall')
 419                    ->openElement('methodName', $method)
 420                    ->closeElement('methodName');
 421  
 422          if (is_array($args) && count($args)) {
 423              $generator->openElement('params');
 424  
 425              foreach ($args as $arg) {
 426                  $generator->openElement('param');
 427                  $arg->generateXml();
 428                  $generator->closeElement('param');
 429              }
 430              $generator->closeElement('params');
 431          }
 432          $generator->closeElement('methodCall');
 433  
 434          return $generator->flush();
 435      }
 436  
 437      /**
 438       * Return XML request
 439       *
 440       * @return string
 441       */
 442      public function __toString()
 443      {
 444          return $this->saveXML();
 445      }
 446  }