interface/modules/zend_modules/library/Zend/Soap/Server.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-2015 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\Soap;
  11
  12 use SoapServer;
  13 use SoapFault;
  14 use Traversable;
  15 use DOMDocument;
  16 use DOMNode;
  17 use SimpleXMLElement;
  18 use ReflectionClass;
  19 use Zend\Server\Server as ZendServerServer;
  20 use Zend\Stdlib\ArrayUtils;
  21
  22 class Server implements ZendServerServer
  23 {
  24     /**
  25      * Actor URI
  26      * @var string URI
  27      */
  28     protected $actor;
  29
  30     /**
  31      * Class registered with this server
  32      * @var string
  33      */
  34     protected $class;
  35
  36     /**
  37      * Server instance
  38      * @var SoapServer
  39      */
  40     protected $server = null;
  41     /**
  42      * Arguments to pass to {@link $class} constructor
  43      * @var array
  44      */
  45     protected $classArgs = array();
  46
  47     /**
  48      * Array of SOAP type => PHP class pairings for handling return/incoming values
  49      * @var array
  50      */
  51     protected $classmap;
  52
  53     /**
  54      * Encoding
  55      * @var string
  56      */
  57     protected $encoding;
  58
  59     /**
  60      * Registered fault exceptions
  61      * @var array
  62      */
  63     protected $faultExceptions = array();
  64
  65     /**
  66      * Container for caught exception during business code execution
  67      * @var \Exception
  68      */
  69     protected $caughtException = null;
  70
  71     /**
  72      * SOAP Server Features
  73      * @var int
  74      */
  75     protected $features;
  76
  77     /**
  78      * Functions registered with this server; may be either an array or the SOAP_FUNCTIONS_ALL constant
  79      * @var array|int
  80      */
  81     protected $functions = array();
  82
  83     /**
  84      * Object registered with this server
  85      */
  86     protected $object;
  87
  88     /**
  89      * Informs if the soap server is in debug mode
  90      * @var bool
  91      */
  92     protected $debug = false;
  93
  94     /**
  95      * Persistence mode; should be one of the SOAP persistence constants
  96      * @var int
  97      */
  98     protected $persistence;
  99
 100     /**
 101      * Request XML
 102      * @var string
 103      */
 104     protected $request;
 105
 106     /**
 107      * Response XML
 108      * @var string
 109      */
 110     protected $response;
 111
 112     /**
 113      * Flag: whether or not {@link handle()} should return a response instead of automatically emitting it.
 114      * @var bool
 115      */
 116     protected $returnResponse = false;
 117
 118     /**
 119      * SOAP version to use; SOAP_1_2 by default, to allow processing of headers
 120      * @var int
 121      */
 122     protected $soapVersion = SOAP_1_2;
 123
 124     /**
 125      * Array of type mappings
 126      * @var array
 127      */
 128     protected $typemap;
 129
 130     /**
 131      * URI namespace for SOAP server
 132      * @var string URI
 133      */
 134     protected $uri;
 135
 136     /**
 137      * URI or path to WSDL
 138      * @var string
 139      */
 140     protected $wsdl;
 141
 142     /**
 143      * WSDL Caching Options of SOAP Server
 144      * @var mixed
 145      */
 146     protected $wsdlCache;
 147
 148     /**
 149      * Constructor
 150      *
 151      * Sets display_errors INI setting to off (prevent client errors due to bad
 152      * XML in response). Registers {@link handlePhpErrors()} as error handler
 153      * for E_USER_ERROR.
 154      *
 155      * If $wsdl is provided, it is passed on to {@link setWSDL()}; if any
 156      * options are specified, they are passed on to {@link setOptions()}.
 157      *
 158      * @param  string $wsdl
 159      * @param  array $options
 160      * @throws Exception\ExtensionNotLoadedException
 161      */
 162     public function __construct($wsdl = null, array $options = null)
 163     {
 164         if (!extension_loaded('soap')) {
 165             throw new Exception\ExtensionNotLoadedException('SOAP extension is not loaded.');
 166         }
 167
 168         if (null !== $wsdl) {
 169             $this->setWSDL($wsdl);
 170         }
 171
 172         if (null !== $options) {
 173             $this->setOptions($options);
 174         }
 175     }
 176
 177     /**
 178      * Set Options
 179      *
 180      * Allows setting options as an associative array of option => value pairs.
 181      *
 182      * @param  array|\Traversable $options
 183      * @return self
 184      */
 185     public function setOptions($options)
 186     {
 187         if ($options instanceof Traversable) {
 188             $options = ArrayUtils::iteratorToArray($options);
 189         }
 190
 191         foreach ($options as $key => $value) {
 192             switch (strtolower($key)) {
 193                 case 'actor':
 194                     $this->setActor($value);
 195                     break;
 196
 197                 case 'classmap':
 198                 case 'class_map':
 199                     $this->setClassmap($value);
 200                     break;
 201
 202                 case 'typemap':
 203                 case 'type_map':
 204                     $this->setTypemap($value);
 205                     break;
 206
 207                 case 'encoding':
 208                     $this->setEncoding($value);
 209                     break;
 210
 211                 case 'soapversion':
 212                 case 'soap_version':
 213                     $this->setSoapVersion($value);
 214                     break;
 215
 216                 case 'uri':
 217                     $this->setUri($value);
 218                     break;
 219
 220                 case 'wsdl':
 221                     $this->setWSDL($value);
 222                     break;
 223
 224                 case 'cache_wsdl':
 225                     $this->setWSDLCache($value);
 226                     break;
 227
 228                 case 'features':
 229                     $this->setSoapFeatures($value);
 230                     break;
 231
 232                 default:
 233                     break;
 234             }
 235         }
 236
 237         return $this;
 238     }
 239
 240     /**
 241      * Return array of options suitable for using with SoapServer constructor
 242      *
 243      * @return array
 244      */
 245     public function getOptions()
 246     {
 247         $options = array();
 248         if (null !== $this->actor) {
 249             $options['actor'] = $this->getActor();
 250         }
 251
 252         if (null !== $this->classmap) {
 253             $options['classmap'] = $this->getClassmap();
 254         }
 255
 256         if (null !== $this->typemap) {
 257             $options['typemap'] = $this->getTypemap();
 258         }
 259
 260         if (null !== $this->encoding) {
 261             $options['encoding'] = $this->getEncoding();
 262         }
 263
 264         if (null !== $this->soapVersion) {
 265             $options['soap_version'] = $this->getSoapVersion();
 266         }
 267
 268         if (null !== $this->uri) {
 269             $options['uri'] = $this->getUri();
 270         }
 271
 272         if (null !== $this->features) {
 273             $options['features'] = $this->getSoapFeatures();
 274         }
 275
 276         if (null !== $this->wsdlCache) {
 277             $options['cache_wsdl'] = $this->getWSDLCache();
 278         }
 279
 280         return $options;
 281     }
 282
 283     /**
 284      * Set encoding
 285      *
 286      * @param  string $encoding
 287      * @return self
 288      * @throws Exception\InvalidArgumentException with invalid encoding argument
 289      */
 290     public function setEncoding($encoding)
 291     {
 292         if (!is_string($encoding)) {
 293             throw new Exception\InvalidArgumentException('Invalid encoding specified');
 294         }
 295
 296         $this->encoding = $encoding;
 297         return $this;
 298     }
 299
 300     /**
 301      * Get encoding
 302      *
 303      * @return string
 304      */
 305     public function getEncoding()
 306     {
 307         return $this->encoding;
 308     }
 309
 310     /**
 311      * Set SOAP version
 312      *
 313      * @param  int $version One of the SOAP_1_1 or SOAP_1_2 constants
 314      * @return self
 315      * @throws Exception\InvalidArgumentException with invalid soap version argument
 316      */
 317     public function setSoapVersion($version)
 318     {
 319         if (!in_array($version, array(SOAP_1_1, SOAP_1_2))) {
 320             throw new Exception\InvalidArgumentException('Invalid soap version specified');
 321         }
 322
 323         $this->soapVersion = $version;
 324         return $this;
 325     }
 326
 327     /**
 328      * Get SOAP version
 329      *
 330      * @return int
 331      */
 332     public function getSoapVersion()
 333     {
 334         return $this->soapVersion;
 335     }
 336
 337     /**
 338      * Check for valid URN
 339      *
 340      * @param  string $urn
 341      * @return true
 342      * @throws Exception\InvalidArgumentException on invalid URN
 343      */
 344     public function validateUrn($urn)
 345     {
 346         $scheme = parse_url($urn, PHP_URL_SCHEME);
 347         if ($scheme === false || $scheme === null) {
 348             throw new Exception\InvalidArgumentException('Invalid URN');
 349         }
 350
 351         return true;
 352     }
 353
 354     /**
 355      * Set actor
 356      *
 357      * Actor is the actor URI for the server.
 358      *
 359      * @param  string $actor
 360      * @return self
 361      */
 362     public function setActor($actor)
 363     {
 364         $this->validateUrn($actor);
 365         $this->actor = $actor;
 366         return $this;
 367     }
 368
 369     /**
 370      * Retrieve actor
 371      *
 372      * @return string
 373      */
 374     public function getActor()
 375     {
 376         return $this->actor;
 377     }
 378
 379     /**
 380      * Set URI
 381      *
 382      * URI in SoapServer is actually the target namespace, not a URI; $uri must begin with 'urn:'.
 383      *
 384      * @param  string $uri
 385      * @return self
 386      */
 387     public function setUri($uri)
 388     {
 389         $this->validateUrn($uri);
 390         $this->uri = $uri;
 391         return $this;
 392     }
 393
 394     /**
 395      * Retrieve URI
 396      *
 397      * @return string
 398      */
 399     public function getUri()
 400     {
 401         return $this->uri;
 402     }
 403
 404     /**
 405      * Set classmap
 406      *
 407      * @param  array $classmap
 408      * @return self
 409      * @throws Exception\InvalidArgumentException for any invalid class in the class map
 410      */
 411     public function setClassmap($classmap)
 412     {
 413         if (!is_array($classmap)) {
 414             throw new Exception\InvalidArgumentException('Classmap must be an array');
 415         }
 416         foreach ($classmap as $class) {
 417             if (!class_exists($class)) {
 418                 throw new Exception\InvalidArgumentException('Invalid class in class map');
 419             }
 420         }
 421
 422         $this->classmap = $classmap;
 423         return $this;
 424     }
 425
 426     /**
 427      * Retrieve classmap
 428      *
 429      * @return mixed
 430      */
 431     public function getClassmap()
 432     {
 433         return $this->classmap;
 434     }
 435
 436     /**
 437      * Set typemap with xml to php type mappings with appropriate validation.
 438      *
 439      * @param  array $typeMap
 440      * @return self
 441      * @throws Exception\InvalidArgumentException
 442      */
 443     public function setTypemap($typeMap)
 444     {
 445         if (!is_array($typeMap)) {
 446             throw new Exception\InvalidArgumentException('Typemap must be an array');
 447         }
 448
 449         foreach ($typeMap as $type) {
 450             if (!is_callable($type['from_xml'])) {
 451                 throw new Exception\InvalidArgumentException(sprintf(
 452                     'Invalid from_xml callback for type: %s',
 453                     $type['type_name']
 454                 ));
 455             }
 456             if (!is_callable($type['to_xml'])) {
 457                 throw new Exception\InvalidArgumentException('Invalid to_xml callback for type: ' . $type['type_name']);
 458             }
 459         }
 460
 461         $this->typemap   = $typeMap;
 462         return $this;
 463     }
 464
 465     /**
 466      * Retrieve typemap
 467      *
 468      * @return array
 469      */
 470     public function getTypemap()
 471     {
 472         return $this->typemap;
 473     }
 474
 475     /**
 476      * Set wsdl
 477      *
 478      * @param  string $wsdl  URI or path to a WSDL
 479      * @return self
 480      */
 481     public function setWSDL($wsdl)
 482     {
 483         $this->wsdl = $wsdl;
 484         return $this;
 485     }
 486
 487     /**
 488      * Retrieve wsdl
 489      *
 490      * @return string
 491      */
 492     public function getWSDL()
 493     {
 494         return $this->wsdl;
 495     }
 496
 497     /**
 498      * Set the SOAP Feature options.
 499      *
 500      * @param  string|int $feature
 501      * @return self
 502      */
 503     public function setSoapFeatures($feature)
 504     {
 505         $this->features = $feature;
 506         return $this;
 507     }
 508
 509     /**
 510      * Return current SOAP Features options
 511      *
 512      * @return int
 513      */
 514     public function getSoapFeatures()
 515     {
 516         return $this->features;
 517     }
 518
 519     /**
 520      * Set the SOAP WSDL Caching Options
 521      *
 522      * @param  string|int|bool $options
 523      * @return self
 524      */
 525     public function setWSDLCache($options)
 526     {
 527         $this->wsdlCache = $options;
 528         return $this;
 529     }
 530
 531     /**
 532      * Get current SOAP WSDL Caching option
 533      */
 534     public function getWSDLCache()
 535     {
 536         return $this->wsdlCache;
 537     }
 538
 539     /**
 540      * Attach a function as a server method
 541      *
 542      * @param  array|string $function Function name, array of function names to attach,
 543      *             or SOAP_FUNCTIONS_ALL to attach all functions
 544      * @param  string $namespace Ignored
 545      * @return self
 546      * @throws Exception\InvalidArgumentException on invalid functions
 547      */
 548     public function addFunction($function, $namespace = '')
 549     {
 550         // Bail early if set to SOAP_FUNCTIONS_ALL
 551         if ($this->functions == SOAP_FUNCTIONS_ALL) {
 552             return $this;
 553         }
 554
 555         if (is_array($function)) {
 556             foreach ($function as $func) {
 557                 if (is_string($func) && function_exists($func)) {
 558                     $this->functions[] = $func;
 559                 } else {
 560                     throw new Exception\InvalidArgumentException('One or more invalid functions specified in array');
 561                 }
 562             }
 563         } elseif (is_string($function) && function_exists($function)) {
 564             $this->functions[] = $function;
 565         } elseif ($function == SOAP_FUNCTIONS_ALL) {
 566             $this->functions = SOAP_FUNCTIONS_ALL;
 567         } else {
 568             throw new Exception\InvalidArgumentException('Invalid function specified');
 569         }
 570
 571         if (is_array($this->functions)) {
 572             $this->functions = array_unique($this->functions);
 573         }
 574
 575         return $this;
 576     }
 577
 578     /**
 579      * Attach a class to a server
 580      *
 581      * Accepts a class name to use when handling requests. Any additional
 582      * arguments will be passed to that class' constructor when instantiated.
 583      *
 584      * See {@link setObject()} to set pre-configured object instances as request handlers.
 585      *
 586      * @param  string|object $class Class name or object instance which executes
 587      *             SOAP Requests at endpoint.
 588      * @param  string $namespace
 589      * @param  null|array $argv
 590      * @return self
 591      * @throws Exception\InvalidArgumentException if called more than once, or if class does not exist
 592      */
 593     public function setClass($class, $namespace = '', $argv = null)
 594     {
 595         if (isset($this->class)) {
 596             throw new Exception\InvalidArgumentException(
 597                 'A class has already been registered with this soap server instance'
 598             );
 599         }
 600
 601         if (is_object($class)) {
 602             return $this->setObject($class);
 603         }
 604
 605         if (!is_string($class)) {
 606             throw new Exception\InvalidArgumentException(sprintf(
 607                 'Invalid class argument (%s)',
 608                 gettype($class)
 609             ));
 610         }
 611
 612         if (!class_exists($class)) {
 613             throw new Exception\InvalidArgumentException(sprintf(
 614                 'Class "%s" does not exist',
 615                 $class
 616             ));
 617         }
 618
 619         $this->class = $class;
 620         if (2 < func_num_args()) {
 621             $argv = func_get_args();
 622             $this->classArgs = array_slice($argv, 2);
 623         }
 624
 625         return $this;
 626     }
 627
 628     /**
 629      * Attach an object to a server
 630      *
 631      * Accepts an instantiated object to use when handling requests.
 632      *
 633      * @param  object $object
 634      * @return self
 635      * @throws Exception\InvalidArgumentException
 636      */
 637     public function setObject($object)
 638     {
 639         if (!is_object($object)) {
 640             throw new Exception\InvalidArgumentException(sprintf(
 641                 'Invalid object argument (%s)',
 642                 gettype($object)
 643             ));
 644         }
 645
 646         if (isset($this->object)) {
 647             throw new Exception\InvalidArgumentException(
 648                 'An object has already been registered with this soap server instance'
 649             );
 650         }
 651
 652         $this->object = $object;
 653         return $this;
 654     }
 655
 656     /**
 657      * Return a server definition array
 658      *
 659      * Returns a list of all functions registered with {@link addFunction()},
 660      * merged with all public methods of the class set with {@link setClass()}
 661      * (if any).
 662      *
 663      * @return array
 664      */
 665     public function getFunctions()
 666     {
 667         $functions = array();
 668         if (null !== $this->class) {
 669             $functions = get_class_methods($this->class);
 670         } elseif (null !== $this->object) {
 671             $functions = get_class_methods($this->object);
 672         }
 673
 674         return array_merge((array) $this->functions, $functions);
 675     }
 676
 677     /**
 678      * Unimplemented: Load server definition
 679      *
 680      * @param  array $definition
 681      * @throws Exception\RuntimeException Unimplemented
 682      */
 683     public function loadFunctions($definition)
 684     {
 685         throw new Exception\RuntimeException('Unimplemented method.');
 686     }
 687
 688     /**
 689      * Set server persistence
 690      *
 691      * @param  int $mode SOAP_PERSISTENCE_SESSION or SOAP_PERSISTENCE_REQUEST constants
 692      * @return self
 693      * @throws Exception\InvalidArgumentException
 694      */
 695     public function setPersistence($mode)
 696     {
 697         if (!in_array($mode, array(SOAP_PERSISTENCE_SESSION, SOAP_PERSISTENCE_REQUEST))) {
 698             throw new Exception\InvalidArgumentException('Invalid persistence mode specified');
 699         }
 700
 701         $this->persistence = $mode;
 702         return $this;
 703     }
 704
 705     /**
 706      * Get server persistence
 707      *
 708      * @return int
 709      */
 710     public function getPersistence()
 711     {
 712         return $this->persistence;
 713     }
 714
 715     /**
 716      * Set request
 717      *
 718      * $request may be any of:
 719      * - DOMDocument; if so, then cast to XML
 720      * - DOMNode; if so, then grab owner document and cast to XML
 721      * - SimpleXMLElement; if so, then cast to XML
 722      * - stdClass; if so, calls __toString() and verifies XML
 723      * - string; if so, verifies XML
 724      *
 725      * @param  DOMDocument|DOMNode|SimpleXMLElement|\stdClass|string $request
 726      * @return self
 727      * @throws Exception\InvalidArgumentException
 728      */
 729     protected function _setRequest($request)
 730     {
 731         $xml = null;
 732
 733         if ($request instanceof DOMDocument) {
 734             $xml = $request->saveXML();
 735         } elseif ($request instanceof DOMNode) {
 736             $xml = $request->ownerDocument->saveXML();
 737         } elseif ($request instanceof SimpleXMLElement) {
 738             $xml = $request->asXML();
 739         } elseif (is_object($request) || is_string($request)) {
 740             if (is_object($request)) {
 741                 $xml = $request->__toString();
 742             } else {
 743                 $xml = $request;
 744             }
 745             $xml = trim($xml);
 746
 747             $loadEntities = libxml_disable_entity_loader(true);
 748
 749             $dom = new DOMDocument();
 750             $loadStatus = $dom->loadXML($xml);
 751
 752             libxml_disable_entity_loader($loadEntities);
 753
 754             // @todo check libxml errors ? validate document ?
 755             if (strlen($xml) == 0 || !$loadStatus) {
 756                 throw new Exception\InvalidArgumentException('Invalid XML');
 757             }
 758
 759             foreach ($dom->childNodes as $child) {
 760                 if ($child->nodeType === XML_DOCUMENT_TYPE_NODE) {
 761                     throw new Exception\InvalidArgumentException('Invalid XML: Detected use of illegal DOCTYPE');
 762                 }
 763             }
 764         }
 765
 766         $this->request = $xml;
 767         return $this;
 768     }
 769
 770     /**
 771      * Retrieve request XML
 772      *
 773      * @return string
 774      */
 775     public function getLastRequest()
 776     {
 777         return $this->request;
 778     }
 779
 780     /**
 781      * Set return response flag
 782      *
 783      * If true, {@link handle()} will return the response instead of
 784      * automatically sending it back to the requesting client.
 785      *
 786      * The response is always available via {@link getResponse()}.
 787      *
 788      * @param  bool $flag
 789      * @return self
 790      */
 791     public function setReturnResponse($flag = true)
 792     {
 793         $this->returnResponse = (bool) $flag;
 794         return $this;
 795     }
 796
 797     /**
 798      * Retrieve return response flag
 799      *
 800      * @return bool
 801      */
 802     public function getReturnResponse()
 803     {
 804         return $this->returnResponse;
 805     }
 806
 807     /**
 808      * Get response XML
 809      *
 810      * @return string
 811      */
 812     public function getResponse()
 813     {
 814         return $this->response;
 815     }
 816
 817     /**
 818      * Get SoapServer object
 819      *
 820      * Uses {@link $wsdl} and return value of {@link getOptions()} to instantiate
 821      * SoapServer object, and then registers any functions or class with it, as
 822      * well as persistence.
 823      *
 824      * @return SoapServer
 825      */
 826     public function getSoap()
 827     {
 828         if ($this->server instanceof SoapServer) {
 829             return $this->server;
 830         }
 831
 832         $options = $this->getOptions();
 833         $server  = new SoapServer($this->wsdl, $options);
 834
 835         if (!empty($this->functions)) {
 836             $server->addFunction($this->functions);
 837         }
 838
 839         if (!empty($this->class)) {
 840             $args = $this->classArgs;
 841             array_unshift($args, $this->class);
 842             call_user_func_array(array($server, 'setClass'), $args);
 843         }
 844
 845         if (!empty($this->object)) {
 846             $server->setObject($this->object);
 847         }
 848
 849         if (null !== $this->persistence) {
 850             $server->setPersistence($this->persistence);
 851         }
 852
 853         $this->server = $server;
 854         return $this->server;
 855     }
 856
 857     /**
 858      * Proxy for _getSoap method
 859      * @see _getSoap
 860      * @return SoapServer the soapServer instance
 861     public function getSoap()
 862     {
 863         return $this->_getSoap();
 864     }
 865      */
 866
 867     /**
 868      * Handle a request
 869      *
 870      * Instantiates SoapServer object with options set in object, and
 871      * dispatches its handle() method.
 872      *
 873      * $request may be any of:
 874      * - DOMDocument; if so, then cast to XML
 875      * - DOMNode; if so, then grab owner document and cast to XML
 876      * - SimpleXMLElement; if so, then cast to XML
 877      * - stdClass; if so, calls __toString() and verifies XML
 878      * - string; if so, verifies XML
 879      *
 880      * If no request is passed, pulls request using php:://input (for
 881      * cross-platform compatibility purposes).
 882      *
 883      * @param  DOMDocument|DOMNode|SimpleXMLElement|\stdClass|string $request Optional request
 884      * @return void|string
 885      */
 886     public function handle($request = null)
 887     {
 888         if (null === $request) {
 889             $request = file_get_contents('php://input');
 890         }
 891
 892         // Set Server error handler
 893         $displayErrorsOriginalState = $this->_initializeSoapErrorContext();
 894
 895         $setRequestException = null;
 896         try {
 897             $this->_setRequest($request);
 898         } catch (\Exception $e) {
 899             $setRequestException = $e;
 900         }
 901
 902         $soap = $this->getSoap();
 903
 904         $fault          = false;
 905         $this->response = '';
 906
 907         if ($setRequestException instanceof \Exception) {
 908             // Create SOAP fault message if we've caught a request exception
 909             $fault = $this->fault($setRequestException->getMessage(), 'Sender');
 910         } else {
 911             ob_start();
 912             try {
 913                 $soap->handle($this->request);
 914             } catch (\Exception $e) {
 915                 $fault = $this->fault($e);
 916             }
 917             $this->response = ob_get_clean();
 918         }
 919
 920         // Restore original error handler
 921         restore_error_handler();
 922         ini_set('display_errors', (string) $displayErrorsOriginalState);
 923
 924         // Send a fault, if we have one
 925         if ($fault instanceof SoapFault && !$this->returnResponse) {
 926             $soap->fault($fault->faultcode, $fault->getMessage());
 927
 928             return;
 929         }
 930
 931         // Echo the response, if we're not returning it
 932         if (!$this->returnResponse) {
 933             echo $this->response;
 934
 935             return;
 936         }
 937
 938         // Return a fault, if we have it
 939         if ($fault instanceof SoapFault) {
 940             return $fault;
 941         }
 942
 943         // Return the response
 944         return $this->response;
 945     }
 946
 947     /**
 948      * Method initializes the error context that the SOAPServer environment will run in.
 949      *
 950      * @return bool display_errors original value
 951      */
 952     protected function _initializeSoapErrorContext()
 953     {
 954         $displayErrorsOriginalState = ini_get('display_errors');
 955         ini_set('display_errors', '0');
 956         set_error_handler(array($this, 'handlePhpErrors'), E_USER_ERROR);
 957         return $displayErrorsOriginalState;
 958     }
 959
 960     /**
 961      * Set the debug mode.
 962      * In debug mode, all exceptions are send to the client.
 963      *
 964      * @param  bool $debug
 965      * @return self
 966      */
 967     public function setDebugMode($debug)
 968     {
 969         $this->debug = $debug;
 970         return $this;
 971     }
 972
 973     /**
 974      * Validate and register fault exception
 975      *
 976      * @param  string|array $class Exception class or array of exception classes
 977      * @return self
 978      * @throws Exception\InvalidArgumentException
 979      */
 980     public function registerFaultException($class)
 981     {
 982         if (is_array($class)) {
 983             foreach ($class as $row) {
 984                 $this->registerFaultException($row);
 985             }
 986         } elseif (is_string($class)
 987             && class_exists($class)
 988             && (is_subclass_of($class, 'Exception') || 'Exception' === $class)
 989         ) {
 990             $ref = new ReflectionClass($class);
 991
 992             $this->faultExceptions[] = $ref->getName();
 993             $this->faultExceptions = array_unique($this->faultExceptions);
 994         } else {
 995             throw new Exception\InvalidArgumentException(
 996                 'Argument for Zend\Soap\Server::registerFaultException should be'
 997                 . ' string or array of strings with valid exception names'
 998             );
 999         }
1000
1001         return $this;
1002     }
1003
1004     /**
1005      * Checks if provided fault name is registered as valid in this server.
1006      *
1007      * @param string $fault Name of a fault class
1008      * @return bool
1009      */
1010     public function isRegisteredAsFaultException($fault)
1011     {
1012         if ($this->debug) {
1013             return true;
1014         }
1015
1016         $ref        = new ReflectionClass($fault);
1017         $classNames = $ref->getName();
1018         return in_array($classNames, $this->faultExceptions);
1019     }
1020
1021     /**
1022      * Deregister a fault exception from the fault exception stack
1023      *
1024      * @param  string $class
1025      * @return bool
1026      */
1027     public function deregisterFaultException($class)
1028     {
1029         if (in_array($class, $this->faultExceptions, true)) {
1030             $index = array_search($class, $this->faultExceptions);
1031             unset($this->faultExceptions[$index]);
1032             return true;
1033         }
1034
1035         return false;
1036     }
1037
1038     /**
1039      * Return fault exceptions list
1040      *
1041      * @return array
1042      */
1043     public function getFaultExceptions()
1044     {
1045         return $this->faultExceptions;
1046     }
1047
1048     /**
1049      * Return caught exception during business code execution
1050      * @return null|\Exception caught exception
1051      */
1052     public function getException()
1053     {
1054         return $this->caughtException;
1055     }
1056
1057     /**
1058      * Generate a server fault
1059      *
1060      * Note that the arguments are reverse to those of SoapFault.
1061      *
1062      * If an exception is passed as the first argument, its message and code
1063      * will be used to create the fault object if it has been registered via
1064      * {@Link registerFaultException()}.
1065      *
1066      * @link   http://www.w3.org/TR/soap12-part1/#faultcodes
1067      * @param  string|\Exception $fault
1068      * @param  string $code SOAP Fault Codes
1069      * @return SoapFault
1070      */
1071     public function fault($fault = null, $code = 'Receiver')
1072     {
1073         $this->caughtException = (is_string($fault)) ? new \Exception($fault) : $fault;
1074
1075         if ($fault instanceof \Exception) {
1076             if ($this->isRegisteredAsFaultException($fault)) {
1077                 $message = $fault->getMessage();
1078                 $eCode   = $fault->getCode();
1079                 $code    = empty($eCode) ? $code : $eCode;
1080             } else {
1081                 $message = 'Unknown error';
1082             }
1083         } elseif (is_string($fault)) {
1084             $message = $fault;
1085         } else {
1086             $message = 'Unknown error';
1087         }
1088
1089         $allowedFaultModes = array(
1090             'VersionMismatch',
1091             'MustUnderstand',
1092             'DataEncodingUnknown',
1093             'Sender',
1094             'Receiver',
1095             'Server'
1096         );
1097         if (!in_array($code, $allowedFaultModes)) {
1098             $code = 'Receiver';
1099         }
1100
1101         return new SoapFault($code, $message);
1102     }
1103
1104     /**
1105      * Throw PHP errors as SoapFaults
1106      *
1107      * @param  int $errno
1108      * @param  string $errstr
1109      * @param  string $errfile
1110      * @param  int $errline
1111      * @param  array $errcontext
1112      * @throws SoapFault
1113      */
1114     public function handlePhpErrors($errno, $errstr, $errfile = null, $errline = null, array $errcontext = null)
1115     {
1116         throw $this->fault($errstr, 'Receiver');
1117     }
1118 }