interface/modules/zend_modules/library/Zend/XmlRpc/Fault.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 SimpleXMLElement;
  13
  14 /**
  15  * XMLRPC Faults
  16  *
  17  * Container for XMLRPC faults, containing both a code and a message;
  18  * additionally, has methods for determining if an XML response is an XMLRPC
  19  * fault, as well as generating the XML for an XMLRPC fault response.
  20  *
  21  * To allow method chaining, you may only use the {@link getInstance()} factory
  22  * to instantiate a Zend\XmlRpc\Server\Fault.
  23  */
  24 class Fault
  25 {
  26     /**
  27      * Fault code
  28      * @var int
  29      */
  30     protected $code;
  31
  32     /**
  33      * Fault character encoding
  34      * @var string
  35      */
  36     protected $encoding = 'UTF-8';
  37
  38     /**
  39      * Fault message
  40      * @var string
  41      */
  42     protected $message;
  43
  44     /**
  45      * Internal fault codes => messages
  46      * @var array
  47      */
  48     protected $internal = array(
  49         404 => 'Unknown Error',
  50
  51         // 610 - 619 reflection errors
  52         610 => 'Invalid method class',
  53         611 => 'Unable to attach function or callback; not callable',
  54         612 => 'Unable to load array; not an array',
  55         613 => 'One or more method records are corrupt or otherwise unusable',
  56
  57         // 620 - 629 dispatch errors
  58         620 => 'Method does not exist',
  59         621 => 'Error instantiating class to invoke method',
  60         622 => 'Method missing implementation',
  61         623 => 'Calling parameters do not match signature',
  62
  63         // 630 - 639 request errors
  64         630 => 'Unable to read request',
  65         631 => 'Failed to parse request',
  66         632 => 'Invalid request, no method passed; request must contain a \'methodName\' tag',
  67         633 => 'Param must contain a value',
  68         634 => 'Invalid method name',
  69         635 => 'Invalid XML provided to request',
  70         636 => 'Error creating xmlrpc value',
  71
  72         // 640 - 649 system.* errors
  73         640 => 'Method does not exist',
  74
  75         // 650 - 659 response errors
  76         650 => 'Invalid XML provided for response',
  77         651 => 'Failed to parse response',
  78         652 => 'Invalid response',
  79         653 => 'Invalid XMLRPC value in response',
  80     );
  81
  82     /**
  83      * Constructor
  84      *
  85      */
  86     public function __construct($code = 404, $message = '')
  87     {
  88         $this->setCode($code);
  89         $code = $this->getCode();
  90
  91         if (empty($message) && isset($this->internal[$code])) {
  92             $message = $this->internal[$code];
  93         } elseif (empty($message)) {
  94             $message = 'Unknown error';
  95         }
  96         $this->setMessage($message);
  97     }
  98
  99     /**
 100      * Set the fault code
 101      *
 102      * @param int $code
 103      * @return Fault
 104      */
 105     public function setCode($code)
 106     {
 107         $this->code = (int) $code;
 108         return $this;
 109     }
 110
 111     /**
 112      * Return fault code
 113      *
 114      * @return int
 115      */
 116     public function getCode()
 117     {
 118         return $this->code;
 119     }
 120
 121     /**
 122      * Retrieve fault message
 123      *
 124      * @param string
 125      * @return Fault
 126      */
 127     public function setMessage($message)
 128     {
 129         $this->message = (string) $message;
 130         return $this;
 131     }
 132
 133     /**
 134      * Retrieve fault message
 135      *
 136      * @return string
 137      */
 138     public function getMessage()
 139     {
 140         return $this->message;
 141     }
 142
 143     /**
 144      * Set encoding to use in fault response
 145      *
 146      * @param string $encoding
 147      * @return Fault
 148      */
 149     public function setEncoding($encoding)
 150     {
 151         $this->encoding = $encoding;
 152         AbstractValue::setEncoding($encoding);
 153         return $this;
 154     }
 155
 156     /**
 157      * Retrieve current fault encoding
 158      *
 159      * @return string
 160      */
 161     public function getEncoding()
 162     {
 163         return $this->encoding;
 164     }
 165
 166     /**
 167      * Load an XMLRPC fault from XML
 168      *
 169      * @param string $fault
 170      * @return bool Returns true if successfully loaded fault response, false
 171      * if response was not a fault response
 172      * @throws Exception\ExceptionInterface if no or faulty XML provided, or if fault
 173      * response does not contain either code or message
 174      */
 175     public function loadXml($fault)
 176     {
 177         if (!is_string($fault)) {
 178             throw new Exception\InvalidArgumentException('Invalid XML provided to fault');
 179         }
 180
 181         $xmlErrorsFlag = libxml_use_internal_errors(true);
 182         try {
 183             $xml = new SimpleXMLElement($fault);
 184         } catch (\Exception $e) {
 185             // Not valid XML
 186             throw new Exception\InvalidArgumentException('Failed to parse XML fault: ' .  $e->getMessage(), 500, $e);
 187         }
 188         if (!$xml instanceof SimpleXMLElement) {
 189             $errors = libxml_get_errors();
 190             $errors = array_reduce($errors, function ($result, $item) {
 191                 if (empty($result)) {
 192                     return $item->message;
 193                 }
 194                 return $result . '; ' . $item->message;
 195             }, '');
 196             libxml_use_internal_errors($xmlErrorsFlag);
 197             throw new Exception\InvalidArgumentException('Failed to parse XML fault: ' . $errors, 500);
 198         }
 199         libxml_use_internal_errors($xmlErrorsFlag);
 200
 201         // Check for fault
 202         if (!$xml->fault) {
 203             // Not a fault
 204             return false;
 205         }
 206
 207         if (!$xml->fault->value->struct) {
 208             // not a proper fault
 209             throw new Exception\InvalidArgumentException('Invalid fault structure', 500);
 210         }
 211
 212         $structXml = $xml->fault->value->asXML();
 213         $struct    = AbstractValue::getXmlRpcValue($structXml, AbstractValue::XML_STRING);
 214         $struct    = $struct->getValue();
 215
 216         if (isset($struct['faultCode'])) {
 217             $code = $struct['faultCode'];
 218         }
 219         if (isset($struct['faultString'])) {
 220             $message = $struct['faultString'];
 221         }
 222
 223         if (empty($code) && empty($message)) {
 224             throw new Exception\InvalidArgumentException('Fault code and string required');
 225         }
 226
 227         if (empty($code)) {
 228             $code = '404';
 229         }
 230
 231         if (empty($message)) {
 232             if (isset($this->internal[$code])) {
 233                 $message = $this->internal[$code];
 234             } else {
 235                 $message = 'Unknown Error';
 236             }
 237         }
 238
 239         $this->setCode($code);
 240         $this->setMessage($message);
 241
 242         return true;
 243     }
 244
 245     /**
 246      * Determine if an XML response is an XMLRPC fault
 247      *
 248      * @param string $xml
 249      * @return bool
 250      */
 251     public static function isFault($xml)
 252     {
 253         $fault = new static();
 254         try {
 255             $isFault = $fault->loadXml($xml);
 256         } catch (Exception\ExceptionInterface $e) {
 257             $isFault = false;
 258         }
 259
 260         return $isFault;
 261     }
 262
 263     /**
 264      * Serialize fault to XML
 265      *
 266      * @return string
 267      */
 268     public function saveXml()
 269     {
 270         // Create fault value
 271         $faultStruct = array(
 272             'faultCode'   => $this->getCode(),
 273             'faultString' => $this->getMessage()
 274         );
 275         $value = AbstractValue::getXmlRpcValue($faultStruct);
 276
 277         $generator = AbstractValue::getGenerator();
 278         $generator->openElement('methodResponse')
 279                   ->openElement('fault');
 280         $value->generateXml();
 281         $generator->closeElement('fault')
 282                   ->closeElement('methodResponse');
 283
 284         return $generator->flush();
 285     }
 286
 287     /**
 288      * Return XML fault response
 289      *
 290      * @return string
 291      */
 292     public function __toString()
 293     {
 294         return $this->saveXML();
 295     }
 296 }