interface/modules/zend_modules/library/Zend/XmlRpc/Request.php

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