interface/modules/zend_modules/library/Zend/XmlRpc/Response.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 /**
  13  * XmlRpc Response
  14  *
  15  * Container for accessing an XMLRPC return value and creating the XML response.
  16  */
  17 class Response
  18 {
  19     /**
  20      * Return value
  21      * @var mixed
  22      */
  23     protected $return;
  24
  25     /**
  26      * Return type
  27      * @var string
  28      */
  29     protected $type;
  30
  31     /**
  32      * Response character encoding
  33      * @var string
  34      */
  35     protected $encoding = 'UTF-8';
  36
  37     /**
  38      * Fault, if response is a fault response
  39      * @var null|\Zend\XmlRpc\Fault
  40      */
  41     protected $fault = null;
  42
  43     /**
  44      * Constructor
  45      *
  46      * Can optionally pass in the return value and type hinting; otherwise, the
  47      * return value can be set via {@link setReturnValue()}.
  48      *
  49      * @param mixed $return
  50      * @param string $type
  51      */
  52     public function __construct($return = null, $type = null)
  53     {
  54         $this->setReturnValue($return, $type);
  55     }
  56
  57     /**
  58      * Set encoding to use in response
  59      *
  60      * @param string $encoding
  61      * @return \Zend\XmlRpc\Response
  62      */
  63     public function setEncoding($encoding)
  64     {
  65         $this->encoding = $encoding;
  66         AbstractValue::setEncoding($encoding);
  67         return $this;
  68     }
  69
  70     /**
  71      * Retrieve current response encoding
  72      *
  73      * @return string
  74      */
  75     public function getEncoding()
  76     {
  77         return $this->encoding;
  78     }
  79
  80     /**
  81      * Set the return value
  82      *
  83      * Sets the return value, with optional type hinting if provided.
  84      *
  85      * @param mixed $value
  86      * @param string $type
  87      * @return void
  88      */
  89     public function setReturnValue($value, $type = null)
  90     {
  91         $this->return = $value;
  92         $this->type = (string) $type;
  93     }
  94
  95     /**
  96      * Retrieve the return value
  97      *
  98      * @return mixed
  99      */
 100     public function getReturnValue()
 101     {
 102         return $this->return;
 103     }
 104
 105     /**
 106      * Retrieve the XMLRPC value for the return value
 107      *
 108      * @return \Zend\XmlRpc\AbstractValue
 109      */
 110     protected function _getXmlRpcReturn()
 111     {
 112         return AbstractValue::getXmlRpcValue($this->return);
 113     }
 114
 115     /**
 116      * Is the response a fault response?
 117      *
 118      * @return bool
 119      */
 120     public function isFault()
 121     {
 122         return $this->fault instanceof Fault;
 123     }
 124
 125     /**
 126      * Returns the fault, if any.
 127      *
 128      * @return null|\Zend\XmlRpc\Fault
 129      */
 130     public function getFault()
 131     {
 132         return $this->fault;
 133     }
 134
 135     /**
 136      * Load a response from an XML response
 137      *
 138      * Attempts to load a response from an XMLRPC response, autodetecting if it
 139      * is a fault response.
 140      *
 141      * @param string $response
 142      * @throws Exception\ValueException if invalid XML
 143      * @return bool True if a valid XMLRPC response, false if a fault
 144      * response or invalid input
 145      */
 146     public function loadXml($response)
 147     {
 148         if (!is_string($response)) {
 149             $this->fault = new Fault(650);
 150             $this->fault->setEncoding($this->getEncoding());
 151             return false;
 152         }
 153
 154         // @see ZF-12293 - disable external entities for security purposes
 155         $loadEntities         = libxml_disable_entity_loader(true);
 156         $useInternalXmlErrors = libxml_use_internal_errors(true);
 157         try {
 158             $dom = new \DOMDocument;
 159             $dom->loadXML($response);
 160             foreach ($dom->childNodes as $child) {
 161                 if ($child->nodeType === XML_DOCUMENT_TYPE_NODE) {
 162                     throw new Exception\ValueException(
 163                         'Invalid XML: Detected use of illegal DOCTYPE'
 164                     );
 165                 }
 166             }
 167             // TODO: Locate why this passes tests but a simplexml import doesn't
 168             //$xml = simplexml_import_dom($dom);
 169             $xml = new \SimpleXMLElement($response);
 170             libxml_disable_entity_loader($loadEntities);
 171             libxml_use_internal_errors($useInternalXmlErrors);
 172         } catch (\Exception $e) {
 173             libxml_disable_entity_loader($loadEntities);
 174             libxml_use_internal_errors($useInternalXmlErrors);
 175             // Not valid XML
 176             $this->fault = new Fault(651);
 177             $this->fault->setEncoding($this->getEncoding());
 178             return false;
 179         }
 180
 181         if (!empty($xml->fault)) {
 182             // fault response
 183             $this->fault = new Fault();
 184             $this->fault->setEncoding($this->getEncoding());
 185             $this->fault->loadXml($response);
 186             return false;
 187         }
 188
 189         if (empty($xml->params)) {
 190             // Invalid response
 191             $this->fault = new Fault(652);
 192             $this->fault->setEncoding($this->getEncoding());
 193             return false;
 194         }
 195
 196         try {
 197             if (!isset($xml->params) || !isset($xml->params->param) || !isset($xml->params->param->value)) {
 198                 throw new Exception\ValueException('Missing XML-RPC value in XML');
 199             }
 200             $valueXml = $xml->params->param->value->asXML();
 201             $value = AbstractValue::getXmlRpcValue($valueXml, AbstractValue::XML_STRING);
 202         } catch (Exception\ValueException $e) {
 203             $this->fault = new Fault(653);
 204             $this->fault->setEncoding($this->getEncoding());
 205             return false;
 206         }
 207
 208         $this->setReturnValue($value->getValue());
 209         return true;
 210     }
 211
 212     /**
 213      * Return response as XML
 214      *
 215      * @return string
 216      */
 217     public function saveXml()
 218     {
 219         $value = $this->_getXmlRpcReturn();
 220         $generator = AbstractValue::getGenerator();
 221         $generator->openElement('methodResponse')
 222                   ->openElement('params')
 223                   ->openElement('param');
 224         $value->generateXml();
 225         $generator->closeElement('param')
 226                   ->closeElement('params')
 227                   ->closeElement('methodResponse');
 228
 229         return $generator->flush();
 230     }
 231
 232     /**
 233      * Return XML response
 234      *
 235      * @return string
 236      */
 237     public function __toString()
 238     {
 239         return $this->saveXML();
 240     }
 241 }