library/Zend/Soap/Client.php

   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 license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_Soap
  17  * @subpackage Client
  18  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  19  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  20  * @version    $Id: Client.php 16971 2009-07-22 18:05:45Z mikaelkael $
  21  */
  22
  23 /** Zend_Soap_Server */
  24 require_once 'Zend/Soap/Server.php';
  25
  26 /** Zend_Soap_Client_Local */
  27 require_once 'Zend/Soap/Client/Local.php';
  28
  29 /** Zend_Soap_Client_Common */
  30 require_once 'Zend/Soap/Client/Common.php';
  31
  32 /**
  33  * Zend_Soap_Client
  34  *
  35  * @category   Zend
  36  * @package    Zend_Soap
  37  * @subpackage Client
  38  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  39  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  40  */
  41 class Zend_Soap_Client
  42 {
  43     /**
  44      * Encoding
  45      * @var string
  46      */
  47     protected $_encoding = 'UTF-8';
  48
  49     /**
  50      * Array of SOAP type => PHP class pairings for handling return/incoming values
  51      * @var array
  52      */
  53     protected $_classmap = null;
  54
  55     /**
  56      * Registered fault exceptions
  57      * @var array
  58      */
  59     protected $_faultExceptions = array();
  60
  61     /**
  62      * SOAP version to use; SOAP_1_2 by default, to allow processing of headers
  63      * @var int
  64      */
  65     protected $_soapVersion = SOAP_1_2;
  66
  67     /** Set of other SoapClient options */
  68     protected $_uri                 = null;
  69     protected $_location            = null;
  70     protected $_style               = null;
  71     protected $_use                 = null;
  72     protected $_login               = null;
  73     protected $_password            = null;
  74     protected $_proxy_host          = null;
  75     protected $_proxy_port          = null;
  76     protected $_proxy_login         = null;
  77     protected $_proxy_password      = null;
  78     protected $_local_cert          = null;
  79     protected $_passphrase          = null;
  80     protected $_compression         = null;
  81     protected $_connection_timeout  = null;
  82     protected $_stream_context      = null;
  83     protected $_features            = null;
  84     protected $_cache_wsdl          = null;
  85
  86     /**
  87      * WSDL used to access server
  88      * It also defines Zend_Soap_Client working mode (WSDL vs non-WSDL)
  89      *
  90      * @var string
  91      */
  92     protected $_wsdl = null;
  93
  94     /**
  95      * SoapClient object
  96      *
  97      * @var SoapClient
  98      */
  99     protected $_soapClient;
 100
 101     /**
 102      * Last invoked method
 103      *
 104      * @var string
 105      */
 106     protected $_lastMethod = '';
 107
 108     /**
 109      * SOAP request headers.
 110      *
 111      * Array of SoapHeader objects
 112      *
 113      * @var array
 114      */
 115     protected $_soapInputHeaders = array();
 116
 117     /**
 118      * Permanent SOAP request headers (shared between requests).
 119      *
 120      * Array of SoapHeader objects
 121      *
 122      * @var array
 123      */
 124     protected $_permanentSoapInputHeaders = array();
 125
 126     /**
 127      * Output SOAP headers.
 128      *
 129      * Array of SoapHeader objects
 130      *
 131      * @var array
 132      */
 133     protected $_soapOutputHeaders = array();
 134
 135     /**
 136      * Constructor
 137      *
 138      * @param string $wsdl
 139      * @param array $options
 140      */
 141     public function __construct($wsdl = null, $options = null)
 142     {
 143         if (!extension_loaded('soap')) {
 144             require_once 'Zend/Soap/Client/Exception.php';
 145             throw new Zend_Soap_Client_Exception('SOAP extension is not loaded.');
 146         }
 147
 148         if ($wsdl !== null) {
 149             $this->setWsdl($wsdl);
 150         }
 151         if ($options !== null) {
 152             $this->setOptions($options);
 153         }
 154     }
 155
 156     /**
 157      * Set wsdl
 158      *
 159      * @param string $wsdl
 160      * @return Zend_Soap_Client
 161      */
 162     public function setWsdl($wsdl)
 163     {
 164         $this->_wsdl = $wsdl;
 165         $this->_soapClient = null;
 166
 167         return $this;
 168     }
 169
 170     /**
 171      * Get wsdl
 172      *
 173      * @return string
 174      */
 175     public function getWsdl()
 176     {
 177         return $this->_wsdl;
 178     }
 179
 180     /**
 181      * Set Options
 182      *
 183      * Allows setting options as an associative array of option => value pairs.
 184      *
 185      * @param  array|Zend_Config $options
 186      * @return Zend_Soap_Client
 187      * @throws Zend_SoapClient_Exception
 188      */
 189     public function setOptions($options)
 190     {
 191         if($options instanceof Zend_Config) {
 192             $options = $options->toArray();
 193         }
 194
 195         foreach ($options as $key => $value) {
 196             switch ($key) {
 197                 case 'classmap':
 198                 case 'classMap':
 199                     $this->setClassmap($value);
 200                     break;
 201                 case 'encoding':
 202                     $this->setEncoding($value);
 203                     break;
 204                 case 'soapVersion':
 205                 case 'soap_version':
 206                     $this->setSoapVersion($value);
 207                     break;
 208                 case 'wsdl':
 209                     $this->setWsdl($value);
 210                     break;
 211                 case 'uri':
 212                     $this->setUri($value);
 213                     break;
 214                 case 'location':
 215                     $this->setLocation($value);
 216                     break;
 217                 case 'style':
 218                     $this->setStyle($value);
 219                     break;
 220                 case 'use':
 221                     $this->setEncodingMethod($value);
 222                     break;
 223                 case 'login':
 224                     $this->setHttpLogin($value);
 225                     break;
 226                 case 'password':
 227                     $this->setHttpPassword($value);
 228                     break;
 229                 case 'proxy_host':
 230                     $this->setProxyHost($value);
 231                     break;
 232                 case 'proxy_port':
 233                     $this->setProxyPort($value);
 234                     break;
 235                 case 'proxy_login':
 236                     $this->setProxyLogin($value);
 237                     break;
 238                 case 'proxy_password':
 239                     $this->setProxyPassword($value);
 240                     break;
 241                 case 'local_cert':
 242                     $this->setHttpsCertificate($value);
 243                     break;
 244                 case 'passphrase':
 245                     $this->setHttpsCertPassphrase($value);
 246                     break;
 247                 case 'compression':
 248                     $this->setCompressionOptions($value);
 249                     break;
 250                 case 'stream_context':
 251                     $this->setStreamContext($value);
 252                     break;
 253                 case 'features':
 254                     $this->setSoapFeatures($value);
 255                     break;
 256                 case 'cache_wsdl':
 257                     $this->setWsdlCache($value);
 258                     break;
 259
 260                 // Not used now
 261                 // case 'connection_timeout':
 262                 //     $this->_connection_timeout = $value;
 263                 //    break;
 264
 265                 default:
 266                     require_once 'Zend/Soap/Client/Exception.php';
 267                     throw new Zend_Soap_Client_Exception('Unknown SOAP client option');
 268                     break;
 269             }
 270         }
 271
 272         return $this;
 273     }
 274
 275     /**
 276      * Return array of options suitable for using with SoapClient constructor
 277      *
 278      * @return array
 279      */
 280     public function getOptions()
 281     {
 282         $options = array();
 283
 284         $options['classmap']       = $this->getClassmap();
 285         $options['encoding']       = $this->getEncoding();
 286         $options['soap_version']   = $this->getSoapVersion();
 287         $options['wsdl']           = $this->getWsdl();
 288         $options['uri']            = $this->getUri();
 289         $options['location']       = $this->getLocation();
 290         $options['style']          = $this->getStyle();
 291         $options['use']            = $this->getEncodingMethod();
 292         $options['login']          = $this->getHttpLogin();
 293         $options['password']       = $this->getHttpPassword();
 294         $options['proxy_host']     = $this->getProxyHost();
 295         $options['proxy_port']     = $this->getProxyPort();
 296         $options['proxy_login']    = $this->getProxyLogin();
 297         $options['proxy_password'] = $this->getProxyPassword();
 298         $options['local_cert']     = $this->getHttpsCertificate();
 299         $options['passphrase']     = $this->getHttpsCertPassphrase();
 300         $options['compression']    = $this->getCompressionOptions();
 301         //$options['connection_timeout'] = $this->_connection_timeout;
 302         $options['stream_context'] = $this->getStreamContext();
 303         $options['cache_wsdl']     = $this->getWsdlCache();
 304         $options['features']       = $this->getSoapFeatures();
 305
 306         foreach ($options as $key => $value) {
 307             if ($value == null) {
 308                 unset($options[$key]);
 309             }
 310         }
 311
 312         return $options;
 313     }
 314
 315     /**
 316      * Set SOAP version
 317      *
 318      * @param  int $version One of the SOAP_1_1 or SOAP_1_2 constants
 319      * @return Zend_Soap_Client
 320      * @throws Zend_Soap_Client_Exception with invalid soap version argument
 321      */
 322     public function setSoapVersion($version)
 323     {
 324         if (!in_array($version, array(SOAP_1_1, SOAP_1_2))) {
 325             require_once 'Zend/Soap/Client/Exception.php';
 326             throw new Zend_Soap_Client_Exception('Invalid soap version specified. Use SOAP_1_1 or SOAP_1_2 constants.');
 327         }
 328         $this->_soapVersion = $version;
 329
 330         $this->_soapClient = null;
 331
 332         return $this;
 333     }
 334
 335     /**
 336      * Get SOAP version
 337      *
 338      * @return int
 339      */
 340     public function getSoapVersion()
 341     {
 342         return $this->_soapVersion;
 343     }
 344
 345     /**
 346      * Set classmap
 347      *
 348      * @param  array $classmap
 349      * @return Zend_Soap_Client
 350      * @throws Zend_Soap_Client_Exception for any invalid class in the class map
 351      */
 352     public function setClassmap(array $classmap)
 353     {
 354         foreach ($classmap as $type => $class) {
 355             if (!class_exists($class)) {
 356                 require_once 'Zend/Soap/Client/Exception.php';
 357                 throw new Zend_Soap_Client_Exception('Invalid class in class map');
 358             }
 359         }
 360
 361         $this->_classmap = $classmap;
 362
 363         $this->_soapClient = null;
 364
 365         return $this;
 366     }
 367
 368     /**
 369      * Retrieve classmap
 370      *
 371      * @return mixed
 372      */
 373     public function getClassmap()
 374     {
 375         return $this->_classmap;
 376     }
 377
 378     /**
 379      * Set encoding
 380      *
 381      * @param  string $encoding
 382      * @return Zend_Soap_Client
 383      * @throws Zend_Soap_Client_Exception with invalid encoding argument
 384      */
 385     public function setEncoding($encoding)
 386     {
 387         if (!is_string($encoding)) {
 388             require_once 'Zend/Soap/Client/Exception.php';
 389             throw new Zend_Soap_Client_Exception('Invalid encoding specified');
 390         }
 391
 392         $this->_encoding = $encoding;
 393
 394         $this->_soapClient = null;
 395
 396         return $this;
 397     }
 398
 399     /**
 400      * Get encoding
 401      *
 402      * @return string
 403      */
 404     public function getEncoding()
 405     {
 406         return $this->_encoding;
 407     }
 408
 409     /**
 410      * Check for valid URN
 411      *
 412      * @param  string $urn
 413      * @return true
 414      * @throws Zend_Soap_Client_Exception on invalid URN
 415      */
 416     public function validateUrn($urn)
 417     {
 418         $segs = parse_url($urn);
 419         if (isset($segs['scheme'])) {
 420             return true;
 421         }
 422
 423         require_once 'Zend/Soap/Client/Exception.php';
 424         throw new Zend_Soap_Client_Exception('Invalid URN');
 425     }
 426
 427     /**
 428      * Set URI
 429      *
 430      * URI in Web Service the target namespace
 431      *
 432      * @param  string $uri
 433      * @return Zend_Soap_Client
 434      * @throws Zend_Soap_Client_Exception with invalid uri argument
 435      */
 436     public function setUri($uri)
 437     {
 438         $this->validateUrn($uri);
 439         $this->_uri = $uri;
 440
 441         $this->_soapClient = null;
 442
 443         return $this;
 444     }
 445
 446     /**
 447      * Retrieve URI
 448      *
 449      * @return string
 450      */
 451     public function getUri()
 452     {
 453         return $this->_uri;
 454     }
 455
 456     /**
 457      * Set Location
 458      *
 459      * URI in Web Service the target namespace
 460      *
 461      * @param  string $location
 462      * @return Zend_Soap_Client
 463      * @throws Zend_Soap_Client_Exception with invalid uri argument
 464      */
 465     public function setLocation($location)
 466     {
 467         $this->validateUrn($location);
 468         $this->_location = $location;
 469
 470         $this->_soapClient = null;
 471
 472         return $this;
 473     }
 474
 475     /**
 476      * Retrieve URI
 477      *
 478      * @return string
 479      */
 480     public function getLocation()
 481     {
 482         return $this->_location;
 483     }
 484
 485     /**
 486      * Set request style
 487      *
 488      * @param  int $style One of the SOAP_RPC or SOAP_DOCUMENT constants
 489      * @return Zend_Soap_Client
 490      * @throws Zend_Soap_Client_Exception with invalid style argument
 491      */
 492     public function setStyle($style)
 493     {
 494         if (!in_array($style, array(SOAP_RPC, SOAP_DOCUMENT))) {
 495             require_once 'Zend/Soap/Client/Exception.php';
 496             throw new Zend_Soap_Client_Exception('Invalid request style specified. Use SOAP_RPC or SOAP_DOCUMENT constants.');
 497         }
 498
 499         $this->_style = $style;
 500
 501         $this->_soapClient = null;
 502
 503         return $this;
 504     }
 505
 506     /**
 507      * Get request style
 508      *
 509      * @return int
 510      */
 511     public function getStyle()
 512     {
 513         return $this->_style;
 514     }
 515
 516     /**
 517      * Set message encoding method
 518      *
 519      * @param  int $use One of the SOAP_ENCODED or SOAP_LITERAL constants
 520      * @return Zend_Soap_Client
 521      * @throws Zend_Soap_Client_Exception with invalid message encoding method argument
 522      */
 523     public function setEncodingMethod($use)
 524     {
 525         if (!in_array($use, array(SOAP_ENCODED, SOAP_LITERAL))) {
 526             require_once 'Zend/Soap/Client/Exception.php';
 527             throw new Zend_Soap_Client_Exception('Invalid message encoding method. Use SOAP_ENCODED or SOAP_LITERAL constants.');
 528         }
 529
 530         $this->_use = $use;
 531
 532         $this->_soapClient = null;
 533
 534         return $this;
 535     }
 536
 537     /**
 538      * Get message encoding method
 539      *
 540      * @return int
 541      */
 542     public function getEncodingMethod()
 543     {
 544         return $this->_use;
 545     }
 546
 547     /**
 548      * Set HTTP login
 549      *
 550      * @param  string $login
 551      * @return Zend_Soap_Client
 552      */
 553     public function setHttpLogin($login)
 554     {
 555         $this->_login = $login;
 556
 557         $this->_soapClient = null;
 558
 559         return $this;
 560     }
 561
 562     /**
 563      * Retrieve HTTP Login
 564      *
 565      * @return string
 566      */
 567     public function getHttpLogin()
 568     {
 569         return $this->_login;
 570     }
 571
 572     /**
 573      * Set HTTP password
 574      *
 575      * @param  string $password
 576      * @return Zend_Soap_Client
 577      */
 578     public function setHttpPassword($password)
 579     {
 580         $this->_password = $password;
 581
 582         $this->_soapClient = null;
 583
 584         return $this;
 585     }
 586
 587     /**
 588      * Retrieve HTTP Password
 589      *
 590      * @return string
 591      */
 592     public function getHttpPassword()
 593     {
 594         return $this->_password;
 595     }
 596
 597     /**
 598      * Set proxy host
 599      *
 600      * @param  string $proxyHost
 601      * @return Zend_Soap_Client
 602      */
 603     public function setProxyHost($proxyHost)
 604     {
 605         $this->_proxy_host = $proxyHost;
 606
 607         $this->_soapClient = null;
 608
 609         return $this;
 610     }
 611
 612     /**
 613      * Retrieve proxy host
 614      *
 615      * @return string
 616      */
 617     public function getProxyHost()
 618     {
 619         return $this->_proxy_host;
 620     }
 621
 622     /**
 623      * Set proxy port
 624      *
 625      * @param  int $proxyPort
 626      * @return Zend_Soap_Client
 627      */
 628     public function setProxyPort($proxyPort)
 629     {
 630         $this->_proxy_port = (int)$proxyPort;
 631
 632         $this->_soapClient = null;
 633
 634         return $this;
 635     }
 636
 637     /**
 638      * Retrieve proxy port
 639      *
 640      * @return int
 641      */
 642     public function getProxyPort()
 643     {
 644         return $this->_proxy_port;
 645     }
 646
 647     /**
 648      * Set proxy login
 649      *
 650      * @param  string $proxyLogin
 651      * @return Zend_Soap_Client
 652      */
 653     public function setProxyLogin($proxyLogin)
 654     {
 655         $this->_proxy_login = $proxyLogin;
 656
 657         $this->_soapClient = null;
 658
 659         return $this;
 660     }
 661
 662     /**
 663      * Retrieve proxy login
 664      *
 665      * @return string
 666      */
 667     public function getProxyLogin()
 668     {
 669         return $this->_proxy_login;
 670     }
 671
 672     /**
 673      * Set proxy password
 674      *
 675      * @param  string $proxyLogin
 676      * @return Zend_Soap_Client
 677      */
 678     public function setProxyPassword($proxyPassword)
 679     {
 680         $this->_proxy_password = $proxyPassword;
 681
 682         $this->_soapClient = null;
 683
 684         return $this;
 685     }
 686
 687     /**
 688      * Set HTTPS client certificate path
 689      *
 690      * @param  string $localCert local certificate path
 691      * @return Zend_Soap_Client
 692      * @throws Zend_Soap_Client_Exception with invalid local certificate path argument
 693      */
 694     public function setHttpsCertificate($localCert)
 695     {
 696         if (!is_readable($localCert)) {
 697             require_once 'Zend/Soap/Client/Exception.php';
 698             throw new Zend_Soap_Client_Exception('Invalid HTTPS client certificate path.');
 699         }
 700
 701         $this->_local_cert = $localCert;
 702
 703         $this->_soapClient = null;
 704
 705         return $this;
 706     }
 707
 708     /**
 709      * Get HTTPS client certificate path
 710      *
 711      * @return string
 712      */
 713     public function getHttpsCertificate()
 714     {
 715         return $this->_local_cert;
 716     }
 717
 718     /**
 719      * Set HTTPS client certificate passphrase
 720      *
 721      * @param  string $passphrase
 722      * @return Zend_Soap_Client
 723      */
 724     public function setHttpsCertPassphrase($passphrase)
 725     {
 726         $this->_passphrase = $passphrase;
 727
 728         $this->_soapClient = null;
 729
 730         return $this;
 731     }
 732
 733     /**
 734      * Get HTTPS client certificate passphrase
 735      *
 736      * @return string
 737      */
 738     public function getHttpsCertPassphrase()
 739     {
 740         return $this->_passphrase;
 741     }
 742
 743     /**
 744      * Set compression options
 745      *
 746      * @param  int $compressionOptions
 747      * @return Zend_Soap_Client
 748      */
 749     public function setCompressionOptions($compressionOptions)
 750     {
 751         $this->_compression = $compressionOptions;
 752
 753         $this->_soapClient = null;
 754
 755         return $this;
 756     }
 757
 758     /**
 759      * Get Compression options
 760      *
 761      * @return int
 762      */
 763     public function getCompressionOptions()
 764     {
 765         return $this->_compression;
 766     }
 767
 768     /**
 769      * Retrieve proxy password
 770      *
 771      * @return string
 772      */
 773     public function getProxyPassword()
 774     {
 775         return $this->_proxy_password;
 776     }
 777
 778     /**
 779      * Set Stream Context
 780      *
 781      * @return Zend_Soap_Client
 782      */
 783     public function setStreamContext($context)
 784     {
 785         if(!is_resource($context) || get_resource_type($context) !== "stream-context") {
 786             /**
 787              * @see Zend_Soap_Client_Exception
 788              */
 789             require_once "Zend/Soap/Client/Exception.php";
 790             throw new Zend_Soap_Client_Exception(
 791                 "Invalid stream context resource given."
 792             );
 793         }
 794
 795         $this->_stream_context = $context;
 796         return $this;
 797     }
 798
 799     /**
 800      * Get Stream Context
 801      *
 802      * @return resource
 803      */
 804     public function getStreamContext()
 805     {
 806         return $this->_stream_context;
 807     }
 808
 809     /**
 810      * Set the SOAP Feature options.
 811      *
 812      * @param  string|int $feature
 813      * @return Zend_Soap_Client
 814      */
 815     public function setSoapFeatures($feature)
 816     {
 817         $this->_features = $feature;
 818
 819         $this->_soapClient = null;
 820         return $this;
 821     }
 822
 823     /**
 824      * Return current SOAP Features options
 825      *
 826      * @return int
 827      */
 828     public function getSoapFeatures()
 829     {
 830         return $this->_features;
 831     }
 832
 833     /**
 834      * Set the SOAP Wsdl Caching Options
 835      *
 836      * @param string|int|boolean $caching
 837      * @return Zend_Soap_Client
 838      */
 839     public function setWsdlCache($options)
 840     {
 841         $this->_cache_wsdl = $options;
 842         return $this;
 843     }
 844
 845     /**
 846      * Get current SOAP Wsdl Caching option
 847      */
 848     public function getWsdlCache()
 849     {
 850         return $this->_cache_wsdl;
 851     }
 852
 853     /**
 854      * Retrieve request XML
 855      *
 856      * @return string
 857      */
 858     public function getLastRequest()
 859     {
 860         if ($this->_soapClient !== null) {
 861             return $this->_soapClient->__getLastRequest();
 862         }
 863
 864         return '';
 865     }
 866
 867     /**
 868      * Get response XML
 869      *
 870      * @return string
 871      */
 872     public function getLastResponse()
 873     {
 874         if ($this->_soapClient !== null) {
 875             return $this->_soapClient->__getLastResponse();
 876         }
 877
 878         return '';
 879     }
 880
 881     /**
 882      * Retrieve request headers
 883      *
 884      * @return string
 885      */
 886     public function getLastRequestHeaders()
 887     {
 888         if ($this->_soapClient !== null) {
 889             return $this->_soapClient->__getLastRequestHeaders();
 890         }
 891
 892         return '';
 893     }
 894
 895     /**
 896      * Retrieve response headers (as string)
 897      *
 898      * @return string
 899      */
 900     public function getLastResponseHeaders()
 901     {
 902         if ($this->_soapClient !== null) {
 903             return $this->_soapClient->__getLastResponseHeaders();
 904         }
 905
 906         return '';
 907     }
 908
 909     /**
 910      * Retrieve last invoked method
 911      *
 912      * @return string
 913      */
 914     public function getLastMethod()
 915     {
 916         return $this->_lastMethod;
 917     }
 918
 919     /**
 920      * Do request proxy method.
 921      *
 922      * May be overridden in subclasses
 923      *
 924      * @internal
 925      * @param Zend_Soap_Client_Common $client
 926      * @param string $request
 927      * @param string $location
 928      * @param string $action
 929      * @param int    $version
 930      * @param int    $one_way
 931      * @return mixed
 932      */
 933     public function _doRequest(Zend_Soap_Client_Common $client, $request, $location, $action, $version, $one_way = null)
 934     {
 935         // Perform request as is
 936         if ($one_way == null) {
 937             return call_user_func(array($client,'SoapClient::__doRequest'), $request, $location, $action, $version);
 938         } else {
 939             return call_user_func(array($client,'SoapClient::__doRequest'), $request, $location, $action, $version, $one_way);
 940         }
 941     }
 942
 943     /**
 944      * Initialize SOAP Client object
 945      *
 946      * @throws Zend_Soap_Client_Exception
 947      */
 948     protected function _initSoapClientObject()
 949     {
 950         $wsdl = $this->getWsdl();
 951         $options = array_merge($this->getOptions(), array('trace' => true));
 952
 953         if ($wsdl == null) {
 954             if (!isset($options['location'])) {
 955                 require_once 'Zend/Soap/Client/Exception.php';
 956                 throw new Zend_Soap_Client_Exception('\'location\' parameter is required in non-WSDL mode.');
 957             }
 958             if (!isset($options['uri'])) {
 959                 require_once 'Zend/Soap/Client/Exception.php';
 960                 throw new Zend_Soap_Client_Exception('\'uri\' parameter is required in non-WSDL mode.');
 961             }
 962         } else {
 963             if (isset($options['use'])) {
 964                 require_once 'Zend/Soap/Client/Exception.php';
 965                 throw new Zend_Soap_Client_Exception('\'use\' parameter only works in non-WSDL mode.');
 966             }
 967             if (isset($options['style'])) {
 968                 require_once 'Zend/Soap/Client/Exception.php';
 969                 throw new Zend_Soap_Client_Exception('\'style\' parameter only works in non-WSDL mode.');
 970             }
 971         }
 972         unset($options['wsdl']);
 973
 974         $this->_soapClient = new Zend_Soap_Client_Common(array($this, '_doRequest'), $wsdl, $options);
 975     }
 976
 977
 978     /**
 979      * Perform arguments pre-processing
 980      *
 981      * My be overridden in descendant classes
 982      *
 983      * @param array $arguments
 984      */
 985     protected function _preProcessArguments($arguments)
 986     {
 987         // Do nothing
 988         return $arguments;
 989     }
 990
 991     /**
 992      * Perform result pre-processing
 993      *
 994      * My be overridden in descendant classes
 995      *
 996      * @param array $arguments
 997      */
 998     protected function _preProcessResult($result)
 999     {
1000         // Do nothing
1001         return $result;
1002     }
1003
1004     /**
1005      * Add SOAP input header
1006      *
1007      * @param SoapHeader $header
1008      * @param boolean $permanent
1009      * @return Zend_Soap_Client
1010      */
1011     public function addSoapInputHeader(SoapHeader $header, $permanent = false)
1012     {
1013         if ($permanent) {
1014                 $this->_permanentSoapInputHeaders[] = $header;
1015         } else {
1016                 $this->_soapInputHeaders[] = $header;
1017         }
1018
1019         return $this;
1020     }
1021
1022     /**
1023      * Reset SOAP input headers
1024      *
1025      * @return Zend_Soap_Client
1026      */
1027     public function resetSoapInputHeaders()
1028     {
1029         $this->_permanentSoapInputHeaders = array();
1030         $this->_soapInputHeaders = array();
1031
1032         return $this;
1033     }
1034
1035     /**
1036      * Get last SOAP output headers
1037      *
1038      * @return array
1039      */
1040     public function getLastSoapOutputHeaderObjects()
1041     {
1042         return $this->_soapOutputHeaders;
1043     }
1044
1045     /**
1046      * Perform a SOAP call
1047      *
1048      * @param string $name
1049      * @param array  $arguments
1050      * @return mixed
1051      */
1052     public function __call($name, $arguments)
1053     {
1054         $soapClient = $this->getSoapClient();
1055
1056         $this->_lastMethod = $name;
1057
1058         $soapHeaders = array_merge($this->_permanentSoapInputHeaders, $this->_soapInputHeaders);
1059         $result = $soapClient->__soapCall($name,
1060                                                  $this->_preProcessArguments($arguments),
1061                                                  null, /* Options are already set to the SOAP client object */
1062                                                  (count($soapHeaders) > 0)? $soapHeaders : null,
1063                                                  $this->_soapOutputHeaders);
1064
1065         // Reset non-permanent input headers
1066         $this->_soapInputHeaders = array();
1067
1068         return $this->_preProcessResult($result);
1069     }
1070
1071
1072     /**
1073      * Return a list of available functions
1074      *
1075      * @return array
1076      * @throws Zend_Soap_Client_Exception
1077      */
1078     public function getFunctions()
1079     {
1080         if ($this->getWsdl() == null) {
1081             require_once 'Zend/Soap/Client/Exception.php';
1082             throw new Zend_Soap_Client_Exception('\'getFunctions\' method is available only in WSDL mode.');
1083         }
1084
1085         $soapClient = $this->getSoapClient();
1086         return $soapClient->__getFunctions();
1087     }
1088
1089
1090     /**
1091      * Get used types.
1092      *
1093      * @return array
1094      */
1095
1096     /**
1097      * Return a list of SOAP types
1098      *
1099      * @return array
1100      * @throws Zend_Soap_Client_Exception
1101      */
1102     public function getTypes()
1103     {
1104         if ($this->getWsdl() == null) {
1105             require_once 'Zend/Soap/Client/Exception.php';
1106             throw new Zend_Soap_Client_Exception('\'getTypes\' method is available only in WSDL mode.');
1107         }
1108
1109         $soapClient = $this->getSoapClient();
1110
1111         return $soapClient->__getTypes();
1112     }
1113
1114     /**
1115      * @param SoapClient $soapClient
1116      * @return Zend_Soap_Client
1117      */
1118     public function setSoapClient(SoapClient $soapClient)
1119     {
1120         $this->_soapClient = $soapClient;
1121         return $this;
1122     }
1123
1124     /**
1125      * @return SoapClient
1126      */
1127     public function getSoapClient()
1128     {
1129         if ($this->_soapClient == null) {
1130             $this->_initSoapClientObject();
1131         }
1132         return $this->_soapClient;
1133     }
1134
1135     /**
1136      * @param string $name
1137      * @param string $value
1138      * @return Zend_Soap_Client
1139      */
1140     public function setCookie($cookieName, $cookieValue=null)
1141     {
1142         $soapClient = $this->getSoapClient();
1143         $soapClient->__setCookie($cookieName, $cookieValue);
1144         return $this;
1145     }
1146 }